From 5d63ef8cf474ab87e930fa2804c0aff75ee53d0c Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 20:48:43 +1000 Subject: [PATCH 01/10] Tests etc. --- crates/osprey-cli/tests/cli_e2e.rs | 83 +++ .../osprey-types/src/generic_effects_tests.rs | 407 +++++++++++++++ .../src/generics_apply_ml_tests.rs | 327 ++++++++++++ .../osprey-types/src/generics_apply_tests.rs | 471 ++++++++++++++++++ .../osprey-types/src/generics_decl_tests.rs | 381 ++++++++++++++ .../src/generics_variance_tests.rs | 350 +++++++++++++ crates/osprey-types/src/lib.rs | 10 + crates/osprey-types/src/testutil.rs | 78 ++- docs/plans/0015-generics-and-variance.md | 24 +- docs/specs/0003-Syntax.md | 22 + docs/specs/0004-TypeSystem.md | 41 ++ docs/specs/0005-FunctionCalls.md | 9 + docs/specs/0024-MLFlavorSyntax.md | 3 + .../ml_turbofish_no_declared_binder.ospo | 8 + ...ish_no_declared_binder.ospo.expectedoutput | 1 + .../ml_turbofish_type_arg_arity.ospo | 9 + ...rbofish_type_arg_arity.ospo.expectedoutput | 1 + .../turbofish_argument_contradiction.ospo | 9 + ...argument_contradiction.ospo.expectedoutput | 1 + .../turbofish_no_declared_binder.ospo | 10 + ...ish_no_declared_binder.ospo.expectedoutput | 1 + .../turbofish_type_arg_arity.ospo | 9 + ...rbofish_type_arg_arity.ospo.expectedoutput | 1 + .../turbofish_type_arg_too_few.ospo | 9 + ...ofish_type_arg_too_few.ospo.expectedoutput | 1 + .../turbofish_variance_marker.ospo | 9 + ...bofish_variance_marker.ospo.expectedoutput | 1 + .../type_equality_comprehensive.test.osp | 24 +- ...lity_comprehensive.test.osp.expectedoutput | 1 + .../type_equality_comprehensive.test.ospml | 27 +- tree-sitter-osprey/test/corpus/osprey.txt | 114 +++++ 31 files changed, 2429 insertions(+), 13 deletions(-) create mode 100644 crates/osprey-types/src/generic_effects_tests.rs create mode 100644 crates/osprey-types/src/generics_apply_ml_tests.rs create mode 100644 crates/osprey-types/src/generics_apply_tests.rs create mode 100644 crates/osprey-types/src/generics_decl_tests.rs create mode 100644 crates/osprey-types/src/generics_variance_tests.rs create mode 100644 examples/failscompilation/ml_turbofish_no_declared_binder.ospo create mode 100644 examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput create mode 100644 examples/failscompilation/ml_turbofish_type_arg_arity.ospo create mode 100644 examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput create mode 100644 examples/failscompilation/turbofish_argument_contradiction.ospo create mode 100644 examples/failscompilation/turbofish_argument_contradiction.ospo.expectedoutput create mode 100644 examples/failscompilation/turbofish_no_declared_binder.ospo create mode 100644 examples/failscompilation/turbofish_no_declared_binder.ospo.expectedoutput create mode 100644 examples/failscompilation/turbofish_type_arg_arity.ospo create mode 100644 examples/failscompilation/turbofish_type_arg_arity.ospo.expectedoutput create mode 100644 examples/failscompilation/turbofish_type_arg_too_few.ospo create mode 100644 examples/failscompilation/turbofish_type_arg_too_few.ospo.expectedoutput create mode 100644 examples/failscompilation/turbofish_variance_marker.ospo create mode 100644 examples/failscompilation/turbofish_variance_marker.ospo.expectedoutput diff --git a/crates/osprey-cli/tests/cli_e2e.rs b/crates/osprey-cli/tests/cli_e2e.rs index 49a88d9f..2b1e3d01 100644 --- a/crates/osprey-cli/tests/cli_e2e.rs +++ b/crates/osprey-cli/tests/cli_e2e.rs @@ -1417,3 +1417,86 @@ fn error_result_assertions_render_the_error() { ); assert!(o.stdout.contains("not ok 1 - div"), "{}", o.stdout); } + +/// The whole call-site type-application pipeline — parse, check, lower, emit, +/// link, run — for the shape that has no other spelling: a binder appearing in +/// no parameter position. [TYPE-GENERICS-APPLY] +#[test] +fn a_written_type_argument_pins_an_instantiation_end_to_end() { + let prog = temp_osp( + "turbofish_run", + "fn identity(x: T) -> T = x\n\ + fn emptyOf() -> List = []\n\ + fn pickOf(first: T, second: U) -> T = first\n\ + let n = identity(5)\n\ + let s = identity(\"os\")\n\ + let nested = length(identity>([1, 2]))\n\ + let empty = length(emptyOf())\n\ + let kept = pickOf(7, \"seven\")\n\ + print(\"n=${n} s=${s} nested=${nested} empty=${empty} kept=${kept}\")\n", + ); + let o = run_file(&prog, &["--run"]); + assert_eq!(o.code, Some(0), "stderr={}", o.stderr); + assert_eq!(o.stdout, "n=5 s=os nested=2 empty=0 kept=7\n"); +} + +/// The ML twin of the same program prints the same bytes ([FLAVOR-IR-EQUIV]). +#[test] +fn the_ml_written_type_argument_prints_the_same_bytes() { + let path = std::env::temp_dir().join("osprey_cli_e2e_turbofish_run_ml.ospml"); + let _ = std::fs::write( + &path, + "identity : T -> T\n\ + identity x = x\n\ + emptyOf : Unit -> List\n\ + emptyOf () = []\n\ + pickOf : (T, U) -> T\n\ + pickOf (first, second) = first\n\ + n = identity 5\n\ + s = identity \"os\"\n\ + nested = length (identity> [1, 2])\n\ + empty = length (emptyOf ())\n\ + kept = pickOf (7, \"seven\")\n\ + print \"n=${n} s=${s} nested=${nested} empty=${empty} kept=${kept}\"\n", + ); + let o = run_file(&path, &["--run"]); + assert_eq!(o.code, Some(0), "stderr={}", o.stderr); + assert_eq!(o.stdout, "n=5 s=os nested=2 empty=0 kept=7\n"); +} + +/// A written list that misses the declared binder count is rejected before +/// anything is emitted, naming both counts. [TYPE-GENERICS-APPLY] +#[test] +fn a_written_type_argument_count_mismatch_is_rejected_by_the_cli() { + let prog = temp_osp( + "turbofish_arity", + "fn identity(x: T) -> T = x\n\ + print(\"${identity(5)}\")\n", + ); + let o = run_file(&prog, &["--check"]); + assert_ne!(o.code, Some(0), "stdout={}", o.stdout); + assert!( + o.stderr + .contains("function `identity` takes 1 type argument(s), got 2"), + "stderr={}", + o.stderr + ); +} + +/// A written argument contradicting the value argument is a type error, not a +/// silently ignored annotation. [TYPE-GENERICS-APPLY] +#[test] +fn a_contradicting_written_type_argument_is_rejected_by_the_cli() { + let prog = temp_osp( + "turbofish_contradiction", + "fn identity(x: T) -> T = x\n\ + print(\"${identity(\\\"text\\\")}\")\n", + ); + let o = run_file(&prog, &["--check"]); + assert_ne!(o.code, Some(0), "stdout={}", o.stdout); + assert!( + o.stderr.contains("cannot unify int with string"), + "stderr={}", + o.stderr + ); +} diff --git a/crates/osprey-types/src/generic_effects_tests.rs b/crates/osprey-types/src/generic_effects_tests.rs new file mode 100644 index 00000000..de7b0c25 --- /dev/null +++ b/crates/osprey-types/src/generic_effects_tests.rs @@ -0,0 +1,407 @@ +//! Spec-driven assertions for **generic effects** ([EFFECTS-GENERIC-DECL], +//! [EFFECTS-GENERIC-INSTANTIATION], [EFFECTS-GENERIC-RUNTIME], +//! [EFFECTS-GENERIC-ROWS], docs/specs/0017-AlgebraicEffects.md). +//! +//! Discharge across instantiations is already exercised by +//! `effect_rows_tests.rs`; this module states the parts of the generic-effect +//! surface that module does not touch — the DECLARATION's variance positions, +//! the written instantiation spellings (`handle Stash`, +//! `perform Stash.take()`), rows with several generic entries, and the ML +//! twins of each. + +use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position_message}; +use osprey_syntax::Flavor; + +/// The position diagnostic for an effect declaration's OPERATION. +fn op_position_message(param: &str, marker: &str, position: &str, op: &str, owner: &str) -> String { + variance_position_message(param, marker, position, "operation", op, owner) +} + +/// A generic effect plus a handler that discharges it at `instantiation`. +fn stash_program(instantiation: &str, answer: &str) -> String { + format!( + r#"effect Stash {{ + take: fn() -> T +}} +fn main() -> Unit = {{ + let held = handle Stash{instantiation} + take => {answer} + in perform Stash{instantiation}.take() + print("${{held}}") +}}"# + ) +} + +// --------------------------------------------------------------------------- +// [EFFECTS-GENERIC-DECL] — operation parameters are inputs, results outputs +// --------------------------------------------------------------------------- + +/// "An effect may declare type parameters, including `in` and `out` variance." +#[test] +fn a_generic_effect_declares_type_parameters() { + accepts( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit + take: fn() -> T +} +print("declared")"#, + ); +} + +/// An operation RESULT is an output position: `out T` belongs there. +#[test] +fn out_is_legal_in_an_operation_result() { + accepts( + Flavor::Default, + r#"effect Source { + next: fn() -> T +} +print("declared")"#, + ); +} + +/// An operation PARAMETER is an input position: `out T` is rejected. +#[test] +fn out_in_an_operation_parameter_is_rejected() { + rejects_with( + Flavor::Default, + r#"effect Bad { + send: fn(T) -> Unit +} +print("declared")"#, + &op_position_message("T", "out", "input", "send", "Bad"), + ); +} + +/// The contravariant mirror: `in T` belongs in an operation parameter. +#[test] +fn in_is_legal_in_an_operation_parameter() { + accepts( + Flavor::Default, + r#"effect Sink { + send: fn(T) -> Unit +} +print("declared")"#, + ); +} + +/// …and is rejected in an operation result. +#[test] +fn in_in_an_operation_result_is_rejected() { + rejects_with( + Flavor::Default, + r#"effect Bad { + next: fn() -> T +} +print("declared")"#, + &op_position_message("T", "in", "output", "next", "Bad"), + ); +} + +/// An invariant parameter sits in either position. +#[test] +fn an_invariant_effect_parameter_is_legal_in_both_positions() { + accepts( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit + take: fn() -> T +} +print("declared")"#, + ); +} + +/// Two binders on one effect are independent. +#[test] +fn an_effect_may_declare_two_binders() { + accepts( + Flavor::Default, + r#"effect Table { + get: fn(K) -> V +} +print("declared")"#, + ); +} + +// --------------------------------------------------------------------------- +// [EFFECTS-GENERIC-INSTANTIATION] — the written instantiation +// --------------------------------------------------------------------------- + +/// "Each handler site instantiates a generic effect independently." +#[test] +fn a_written_instantiation_is_accepted_on_handle_and_perform() { + accepts(Flavor::Default, &stash_program("", "9")); +} + +/// The same program at a different instantiation. +#[test] +fn a_written_string_instantiation_is_accepted() { + accepts(Flavor::Default, &stash_program("", "\"ready\"")); +} + +/// "Handler arm values and performs in the handled body must agree on that +/// instantiation" — an arm answering the wrong type is rejected. +#[test] +fn a_handler_arm_disagreeing_with_the_written_instantiation_is_rejected() { + rejects_with( + Flavor::Default, + &stash_program("", "\"ready\""), + "cannot unify", + ); +} + +/// The instantiation may also be left to inference at both sites. +#[test] +fn an_inferred_instantiation_is_accepted() { + accepts(Flavor::Default, &stash_program("", "9")); +} + +/// A written `handle Stash` does not discharge a `Stash` perform. +#[test] +fn a_written_handler_instantiation_discharges_only_its_own_operations() { + rejected_somehow( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit +} +fn store() = perform Stash.put("text") +fn main() -> Unit = { + let done = handle Stash + put v => print("stored") + in store() + print("${done}") +}"#, + ); +} + +/// Two handlers at two instantiations coexist in ONE program: the sites are +/// independent, not one global instantiation. +#[test] +fn two_instantiations_of_one_effect_coexist() { + accepts( + Flavor::Default, + r#"effect Stash { + take: fn() -> T +} +fn main() -> Unit = { + let n = handle Stash + take => 1 + in perform Stash.take() + let s = handle Stash + take => "one" + in perform Stash.take() + print("${n}${s}") +}"#, + ); +} + +/// A written instantiation whose arity misses the declaration is rejected. +#[test] +fn a_written_effect_instantiation_arity_is_checked() { + rejected_somehow( + Flavor::Default, + r#"effect Stash { + take: fn() -> T +} +fn main() -> Unit = { + let held = handle Stash + take => 1 + in perform Stash.take() + print("${held}") +}"#, + ); +} + +// --------------------------------------------------------------------------- +// [EFFECTS-GENERIC-ROWS] — a row entry pins an instantiation +// --------------------------------------------------------------------------- + +/// "A row entry such as `!Stash` pins the generic effect instantiation +/// used by performs in that function body." +#[test] +fn a_row_entry_pins_the_instantiation() { + accepts( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit +} +fn store() -> Unit !Stash = perform Stash.put(42) +fn main() -> Unit = { + let done = handle Stash + put v => print("stored ${v}") + in store() + print("${done}") +}"#, + ); +} + +/// A body contradicting its own pinned row is rejected, naming the row. +#[test] +fn a_body_contradicting_its_pinned_row_is_rejected() { + rejects_with( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit +} +fn store() -> Unit !Stash = perform Stash.put("text") +fn main() -> Unit = { + let done = handle Stash + put v => print("stored") + in store() + print("${done}") +}"#, + "outside its declared row", + ); +} + +/// "A bare generic entry leaves its arguments to inference." +#[test] +fn a_bare_generic_row_entry_leaves_its_arguments_to_inference() { + accepts( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit +} +fn store() -> Unit !Stash = perform Stash.put(42) +fn main() -> Unit = { + let done = handle Stash + put v => print("stored ${v}") + in store() + print("${done}") +}"#, + ); +} + +/// A bracketed row may carry SEVERAL generic entries, each at its own +/// instantiation ([EFFECTS-GENERIC-ROWS], `effectSet`). +#[test] +fn a_bracketed_row_carries_several_generic_entries() { + accepts( + Flavor::Default, + r#"effect Read { + get: fn() -> T +} +effect Write { + put: fn(T) -> Unit +} +fn copy() -> Unit ![Read, Write] = perform Write.put("${perform Read.get()}") +fn main() -> Unit = { + let done = handle Read + get => 7 + in handle Write + put v => print("wrote ${v}") + in copy() + print("${done}") +}"#, + ); +} + +// --------------------------------------------------------------------------- +// [EFFECTS-GENERIC-RUNTIME] — the checker-visible half of the erased ABI +// --------------------------------------------------------------------------- + +/// "Static discharge distinguishes resolved instantiations" — an undischarged +/// operation is named AT its instantiation at program entry, which is what the +/// runtime's mangled key (`Stash$string`) mirrors. +#[test] +fn an_unhandled_generic_operation_is_named_at_its_instantiation() { + rejects_with( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit +} +fn store() = perform Stash.put("text") +fn main() -> Unit = store()"#, + "Stash.put", + ); +} + +// --------------------------------------------------------------------------- +// [FLAVOR-ML-GENERICS] — the ML spellings of the same effect surface +// --------------------------------------------------------------------------- + +/// "Effects use the same binder form: `effect Stash T`." ML operation arrows +/// are effectful (`=>`), as the corpus writes them. +#[test] +fn ml_effect_binders_are_juxtaposed() { + accepts( + Flavor::Ml, + "effect Stash T\n take : Unit => T\nprint \"declared\"\n", + ); +} + +/// "Effect rows apply arguments with angles: `! Stash`." +#[test] +fn ml_rows_apply_arguments_with_angles() { + accepts( + Flavor::Ml, + "effect Stash T\n put : T => Unit\n\ + store : Unit -> Unit ! Stash\n\ + store () = perform Stash.put 42\n\ + main () =\n\ + \x20 done = handle Stash\n\ + \x20 put v => print \"stored\"\n\ + \x20 in store ()\n\ + \x20 print \"${done}\"\n", + ); +} + +/// A bracketed ML row carries several generic entries: `! [Read, Write]`. +#[test] +fn ml_a_bracketed_row_carries_several_generic_entries() { + accepts( + Flavor::Ml, + "effect Read T\n get : Unit => T\n\ + effect Write T\n put : T => Unit\n\ + copy : Unit -> Unit ! [Read, Write]\n\ + copy () = perform Write.put \"${perform Read.get ()}\"\n", + ); +} + +/// The ML twin of the operation-position rule. +#[test] +fn ml_out_in_an_operation_parameter_is_rejected() { + rejects_with( + Flavor::Ml, + "effect Bad out T\n send : T => Unit\nprint \"declared\"\n", + &op_position_message("T", "out", "input", "send", "Bad"), + ); +} + +/// The ML twin of the written-instantiation rules. +#[test] +fn ml_a_written_instantiation_is_accepted_on_handle_and_perform() { + accepts( + Flavor::Ml, + "effect Stash T\n take : Unit => T\n\ + main () =\n\ + \x20 held = handle Stash\n\ + \x20 take => 9\n\ + \x20 in perform Stash.take ()\n\ + \x20 print \"${held}\"\n", + ); +} + +// --------------------------------------------------------------------------- +// Spec-vs-language drift, stated as a test rather than left as prose +// --------------------------------------------------------------------------- + +/// [EFFECTS-GENERIC-INSTANTIATION]'s own example writes the handled body after +/// `do`, not `in`. The language accepts only `in` today; the rename is plan +/// 0027 phase 0. One of the two sources is stale, and this test says which. +#[test] +fn the_spec_writes_a_handled_body_after_do() { + accepts( + Flavor::Default, + r#"effect Stash { + put: fn(T) -> Unit + take: fn() -> T +} +let word = handle Stash + put value => print(value) + take => "ready" +do perform Stash.take() +print(word)"#, + ); +} diff --git a/crates/osprey-types/src/generics_apply_ml_tests.rs b/crates/osprey-types/src/generics_apply_ml_tests.rs new file mode 100644 index 00000000..6196b6cc --- /dev/null +++ b/crates/osprey-types/src/generics_apply_ml_tests.rs @@ -0,0 +1,327 @@ +//! The ML half of **call-site type application** ([TYPE-GENERICS-APPLY], +//! docs/specs/0004-TypeSystem.md; spelling in [FLAVOR-ML-GENERICS], +//! docs/specs/0024-MLFlavorSyntax.md). +//! +//! Both surfaces lower to the same canonical node ([FLAVOR-BOUNDARY]), so every +//! Default assertion in `generics_apply_tests.rs` has a twin here and the two +//! flavors must agree down to the diagnostic sentence. + +use crate::testutil::{accepts, fn_arity_message, rejected_somehow, rejects_with}; +use osprey_syntax::Flavor; + +/// The ML twin of `IDENTITY`: the binder lives on the signature line. +const ML_IDENTITY: &str = "identity : T -> T\nidentity x = x\n"; +/// The ML twin of `PICK`. +const ML_PICK: &str = "pick : (T, U) -> T\npick (first, second) = first\n"; + +/// "Call-site type arguments attach to the callee name and precede the +/// juxtaposed argument: `identity 5`." +#[test] +fn ml_type_application_pins_a_binder() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity 5 +print "${{pinned}}""# + ), + ); +} + +/// The ML twin of the no-parameter-position case. +#[test] +fn ml_type_application_pins_a_binder_no_argument_mentions() { + accepts( + Flavor::Ml, + r#"empty : Unit -> List +empty () = [] +held = empty () +print "${length held}""#, + ); +} + +/// Parenthesised ML argument tuples take type arguments too. +#[test] +fn ml_type_application_binds_binders_positionally() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_PICK}kept = pick (1, "two") +print "${{kept}}""# + ), + ); +} + +/// The swapped ML twin must be rejected. +#[test] +fn ml_swapped_type_arguments_are_rejected() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_PICK}kept = pick (1, "two") +print "${{kept}}""# + ), + "cannot unify", + ); +} + +/// The arity contract lives in the shared core, so ML reports the same +/// sentence as Default ([FLAVOR-BOUNDARY]). +#[test] +fn ml_type_application_arity_is_checked() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity 5 +print "${{pinned}}""# + ), + &fn_arity_message("identity", 1, 2), + ); +} + +/// "A binding without a signature cannot declare function type parameters" — +/// and so cannot be applied at a call site either. +#[test] +fn ml_a_binding_without_a_signature_takes_no_type_arguments() { + rejects_with( + Flavor::Ml, + r#"plain x = x +pinned = plain 5 +print "${pinned}""#, + &fn_arity_message("plain", 0, 1), + ); +} + +/// A nested ML type argument closes with `>>` here too. +#[test] +fn ml_a_type_argument_may_itself_be_generic() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}held = identity> [1, 2] +print "${{length held}}""# + ), + ); +} + +/// The ML control: `<` stays comparison under layout juxtaposition. +#[test] +fn ml_a_comparison_is_not_type_application() { + accepts( + Flavor::Ml, + r#"lower (a, b) = a < b +flag = lower (1, 2) +print "${toString flag}""#, + ); +} + +/// The ML gap rule matches Default's: `identity 5` is not application. +#[test] +fn ml_a_gap_before_the_angle_is_not_type_application() { + rejected_somehow( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity 5 +print "${{pinned}}""# + ), + ); +} + +/// ML variance markers are declaration-site only, at the call site as well. +#[test] +fn ml_a_variance_marker_at_a_call_site_is_rejected() { + rejected_somehow( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity 5 +print "${{pinned}}""# + ), + ); +} + +/// Curry-by-default: the written arguments attach to the callee name, so a +/// curried application takes them exactly once, at the front. +#[test] +fn ml_type_application_survives_curried_application() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_PICK}kept = pick 1 "two" +print "${{kept}}""# + ), + ); +} + +/// The ML twin of the value-argument contradiction. +#[test] +fn ml_type_application_contradicting_the_value_argument_is_rejected() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity "text" +print "${{pinned}}""# + ), + "cannot unify int with string", + ); +} + +/// The ML twin of the expected-type contradiction, pinned by a signature. +#[test] +fn ml_type_application_contradicting_the_expected_type_is_rejected() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned : string +pinned = identity 5 +print "${{pinned}}""# + ), + "cannot unify", + ); +} + +/// The ML twin of "too few type arguments". +#[test] +fn ml_too_few_type_arguments_are_rejected_by_count() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_PICK}kept = pick (1, "two") +print "${{kept}}""# + ), + &fn_arity_message("pick", 2, 1), + ); +} + +/// The ML twin of the lambda rule: `\x => x` declares no binder. +#[test] +fn ml_a_lambda_binding_takes_no_type_arguments() { + rejects_with( + Flavor::Ml, + r#"f = \x => x +pinned = f 5 +print "${pinned}""#, + &fn_arity_message("f", 0, 1), + ); +} + +/// A declared record is a type argument in ML too. +#[test] +fn ml_a_declared_record_may_be_a_type_argument() { + accepts( + Flavor::Ml, + &format!( + r#"type Box T = + value : T +{ML_IDENTITY}held = identity> (Box(value = 7)) +print "${{held.value}}""# + ), + ); +} + +/// A function type is a type argument in ML too. +#[test] +fn ml_a_function_type_may_be_a_type_argument() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}double n = n * 2 ?: 0 +f = identity<(int) -> int> double +print "${{f 21}}""# + ), + ); +} + +/// Two written instantiations of one ML binding coexist. +#[test] +fn ml_two_written_instantiations_coexist() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}n = identity 5 +s = identity "os" +print "${{n}} ${{s}}""# + ), + ); +} + +/// Written arguments do not excuse a wrong value argument: applying `Unit` +/// where `int` was pinned still fails. +#[test] +fn ml_writing_type_arguments_does_not_excuse_the_value_argument() { + rejects_with( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity () +print "${{pinned}}""# + ), + "cannot unify", + ); +} + +/// A pipe target has no juxtaposed argument, so it is not an application site. +#[test] +fn ml_type_arguments_in_a_pipe_target_are_rejected() { + rejected_somehow( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = 5 |> identity +print "${{pinned}}""# + ), + ); +} + +/// An undeclared type name is not a type argument. +#[test] +fn ml_an_undeclared_type_argument_is_rejected() { + rejected_somehow( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity 5 +print "${{pinned}}""# + ), + ); +} + +/// An empty argument list is not a type list in ML either. +#[test] +fn ml_an_empty_type_argument_list_is_rejected() { + rejected_somehow( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}pinned = identity<> 5 +print "${{pinned}}""# + ), + ); +} + +/// Type application inside a lambda body and a match arm. +#[test] +fn ml_type_application_works_inside_lambdas_and_match_arms() { + accepts( + Flavor::Ml, + &format!( + r#"{ML_IDENTITY}wrap = \n => identity n +chosen = match wrap 1 + 1 => identity "one" + _ => identity "other" +print "${{chosen}}""# + ), + ); +} + +/// Call-site application and generic-effect instantiation share one `<` rule +/// in ML as well. +#[test] +fn ml_type_application_coexists_with_generic_effect_instantiation() { + accepts( + Flavor::Ml, + &format!( + r#"effect Stash T + take : Unit => T +{ML_IDENTITY}main () = + held = handle Stash + take => identity 9 + in perform Stash.take () + print "${{held}}""# + ), + ); +} diff --git a/crates/osprey-types/src/generics_apply_tests.rs b/crates/osprey-types/src/generics_apply_tests.rs new file mode 100644 index 00000000..1f18c894 --- /dev/null +++ b/crates/osprey-types/src/generics_apply_tests.rs @@ -0,0 +1,471 @@ +//! Spec-driven assertions for **call-site type application** +//! ([TYPE-GENERICS-APPLY], docs/specs/0004-TypeSystem.md; the ML spelling is +//! [FLAVOR-ML-GENERICS], docs/specs/0024-MLFlavorSyntax.md). +//! +//! Type arguments have three positions in the language: the declaration binder +//! (`fn pick`), the construction site (`Box { … }`) and the call +//! site. The first two land; this module states the third, which is the only +//! spelling that can pin a binder appearing in no parameter position — an +//! annotated `let` pins a *return*, never a binder the arguments never mention. +//! Tracked by plan 0015. +//! +//! Each test states one spec sentence and drives the compiler's public surface +//! — parse, then check — so a snippet the PARSER rejects is reported as a +//! syntax failure instead of being mistaken for a checker rejection. + +use crate::testutil::{accepts, fn_arity_message, rejected_somehow, rejects_with}; +use osprey_syntax::Flavor; + +/// `fn identity` — one binder, mentioned by the parameter and the return. +const IDENTITY: &str = "fn identity(x: T) -> T = x\n"; +/// `fn pick` — two binders, so written ORDER is observable. +const PICK: &str = "fn pick(first: T, second: U) -> T = first\n"; +/// A binder in NO parameter position: inference alone can never pin it. +const EMPTY: &str = "fn empty() -> List = []\n"; + +// --------------------------------------------------------------------------- +// The accepted form — Default flavor +// --------------------------------------------------------------------------- + +/// "`identity(5)` pins the callee's declared binders positionally." +#[test] +fn type_application_pins_a_binder_at_a_call_site() { + accepts( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), + ); +} + +/// "the only spelling that can pin a binder appearing in no parameter +/// position" — nothing else in this program mentions `T`. +#[test] +fn type_application_pins_a_binder_no_argument_mentions() { + accepts( + Flavor::Default, + &format!(r#"{EMPTY}print("${{length(empty())}}")"#), + ); +} + +/// The same call WITHOUT the written argument leaves the binder unresolved, so +/// the accepted case above cannot be passing for an unrelated reason. +#[test] +fn the_unpinnable_binder_is_the_control_for_that_case() { + rejected_somehow( + Flavor::Default, + &format!(r#"{EMPTY}let held = empty() +print("${{length(held)}}")"#), + ); +} + +/// "the written arguments unify with the instantiation the value arguments and +/// the expected type would otherwise infer" — agreement is accepted. +#[test] +fn type_application_agreeing_with_the_value_argument_is_accepted() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}let n: int = identity(5) +print("${{n}}")"# + ), + ); +} + +/// Binders are pinned LEFT TO RIGHT. +#[test] +fn type_application_binds_binders_positionally() { + accepts( + Flavor::Default, + &format!( + r#"{PICK}let kept = pick(1, "two") +print("${{kept}}")"# + ), + ); +} + +/// The swapped twin of the case above must NOT type-check. +#[test] +fn swapped_type_arguments_are_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{PICK}let kept = pick(1, "two") +print("${{kept}}")"# + ), + "cannot unify", + ); +} + +/// A type argument may itself be generic: the `>>` closing two argument lists +/// must lex as two closers, not as one shift operator. +#[test] +fn a_type_argument_may_itself_be_generic() { + accepts( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{length(identity>([1, 2]))}}")"#), + ); +} + +/// Three closers in a row (`>>>`), and a two-argument constructor inside. +#[test] +fn a_type_argument_may_nest_two_levels_deep() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}let groups = identity>>({{"a": [1]}}) +print("${{mapLength(groups)}}")"# + ), + ); +} + +/// A declared record is as good a type argument as a primitive. +#[test] +fn a_declared_record_may_be_a_type_argument() { + accepts( + Flavor::Default, + &format!( + r#"type Box = {{ value: T }} +{IDENTITY}let boxed = identity>(Box {{ value: 7 }}) +print("${{boxed.value}}")"# + ), + ); +} + +/// A function type is a type, so it may be written as a type argument. +#[test] +fn a_function_type_may_be_a_type_argument() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}fn double(n) = n * 2 ?: 0 +let f = identity<(int) -> int>(double) +print("${{f(21)}}")"# + ), + ); +} + +/// `Result` is a type argument like any other — and writing it does NOT +/// unwrap the failure channel ([TYPE-VARIANCE-ASSIGN]). +#[test] +fn a_result_type_may_be_a_type_argument() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}let quotient = identity>(10 / 2) +print("${{quotient ?: 0}}")"# + ), + ); +} + +/// Type application is an expression: it nests inside another call. +#[test] +fn type_application_nests_inside_another_call() { + accepts( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(identity(5))}}")"#), + ); +} + +/// Two written instantiations of ONE binding coexist — monomorphisation is +/// per call site ([TYPE-GENERICS-FN]). +#[test] +fn two_written_instantiations_coexist_in_one_program() { + accepts( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#), + ); +} + +/// Named arguments are orthogonal to type arguments. +#[test] +fn type_application_composes_with_named_arguments() { + accepts( + Flavor::Default, + &format!( + r#"{PICK}let kept = pick(first: 1, second: "two") +print("${{kept}}")"# + ), + ); +} + +/// Receiver-first (UFCS) dispatch keeps the type arguments on the member name. +#[test] +fn type_application_composes_with_receiver_first_dispatch() { + accepts( + Flavor::Default, + &format!( + r#"fn headOr(items: List, fallback: T) -> T = items.listGet(0) ?: fallback +let first = [1, 2].headOr(0) +print("${{first}}")"# + ), + ); +} + +/// A generic HOF's binder may be pinned while the callback stays inferred. +#[test] +fn type_application_pins_a_generic_higher_order_call() { + accepts( + Flavor::Default, + &format!( + r#"fn also(x: T, f: (T) -> T) -> T = f(x) +fn double(n) = n * 2 ?: 0 +print("${{also(21, double)}}")"# + ), + ); +} + +/// The binder in scope may be applied to a RECURSIVE call inside the generic +/// function's own body. +#[test] +fn a_binder_in_scope_may_be_applied_recursively() { + accepts( + Flavor::Default, + &format!( + r#"fn repeat(value: T, times: int) -> T = match times {{ + 0 => value + _ => repeat(value, times - 1 ?: 0) +}} +print("${{repeat(7, 3)}}")"# + ), + ); +} + +/// Inside a lambda body, and inside a match arm — no statement-level special +/// case. +#[test] +fn type_application_works_inside_lambdas_and_match_arms() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}let wrap = |n| => identity(n) +let chosen = match wrap(1) {{ + 1 => identity("one") + _ => identity("other") +}} +print("${{chosen}}")"# + ), + ); +} + +/// Call-site application coexists with the generic-EFFECT instantiation syntax +/// that already ships (`perform Stash.take()`): one `<` rule, two sites. +#[test] +fn type_application_coexists_with_generic_effect_instantiation() { + accepts( + Flavor::Default, + &format!( + r#"effect Stash {{ + take: fn() -> T +}} +{IDENTITY}fn main() -> Unit = {{ + let held = handle Stash + take => identity(9) + in perform Stash.take() + print("${{held}}") +}}"# + ), + ); +} + +// --------------------------------------------------------------------------- +// The rejections +// --------------------------------------------------------------------------- + +/// "A written argument that contradicts the value arguments … is a type error, +/// not a silently ignored annotation." +#[test] +fn type_application_contradicting_the_value_argument_is_rejected() { + rejects_with( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity("text")}}")"#), + "cannot unify int with string", + ); +} + +/// A contradiction against the EXPECTED type is caught the same way, even +/// though the value argument agrees with what was written. +#[test] +fn type_application_contradicting_the_expected_type_is_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{IDENTITY}let s: string = identity(5) +print(s)"# + ), + "cannot unify", + ); +} + +/// A contradiction one level down: the written `List` disagrees with a +/// `List` value. +#[test] +fn a_nested_type_argument_contradiction_is_rejected() { + rejects_with( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{length(identity>(["a"]))}}")"#), + "cannot unify", + ); +} + +/// "The count must equal the callee's declared binder count." +#[test] +fn too_many_type_arguments_are_rejected_by_count() { + rejects_with( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), + &fn_arity_message("identity", 1, 2), + ); +} + +/// The same rule in the other direction: two binders, one written argument. +#[test] +fn too_few_type_arguments_are_rejected_by_count() { + rejects_with( + Flavor::Default, + &format!( + r#"{PICK}let kept = pick(1, "two") +print("${{kept}}")"# + ), + &fn_arity_message("pick", 2, 1), + ); +} + +/// "A callee that declares no binders … takes no type arguments." An +/// unannotated function is implicitly polymorphic, which is NOT a binder. +#[test] +fn a_function_without_a_binder_takes_no_type_arguments() { + rejects_with( + Flavor::Default, + r#"fn plain(x) = x +print("${plain(5)}")"#, + &fn_arity_message("plain", 0, 1), + ); +} + +/// A lambda binding declares no binders either. +#[test] +fn a_lambda_binding_takes_no_type_arguments() { + rejects_with( + Flavor::Default, + r#"let f = |x| => x +print("${f(5)}")"#, + &fn_arity_message("f", 0, 1), + ); +} + +/// A parameter holding a function value declares no binders. +#[test] +fn a_function_valued_parameter_takes_no_type_arguments() { + rejects_with( + Flavor::Default, + r#"fn apply(f, x) = f(x) +print("${apply(|n| => n, 5)}")"#, + &fn_arity_message("f", 0, 1), + ); +} + +/// Value arity is still checked when type arguments are written: the two +/// argument lists are independent contracts. +#[test] +fn writing_type_arguments_does_not_excuse_a_missing_value_argument() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity()}}")"#), + ); +} + +/// "Variance markers are not permitted, exactly as on the binder itself." +#[test] +fn a_covariance_marker_at_a_call_site_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), + ); +} + +/// The contravariant half of the same rule. +#[test] +fn a_contravariance_marker_at_a_call_site_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), + ); +} + +/// A type argument names a TYPE. An undeclared name is not one. +#[test] +fn an_undeclared_type_argument_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), + ); +} + +/// An empty argument list is not a type list. +#[test] +fn an_empty_type_argument_list_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity<>(5)}}")"#), + ); +} + +/// "the matching `>` immediately precedes the call's argument list" — with no +/// argument list there is no type application, so a bare `identity` value +/// is not the way to specialise a function value. +#[test] +fn type_arguments_without_an_argument_list_are_rejected() { + rejected_somehow( + Flavor::Default, + &format!( + r#"{IDENTITY}let g = identity +print("${{g(5)}}")"# + ), + ); +} + +/// "recognised when the `<` immediately follows the callee name" — a gap makes +/// it the comparison operator again, and `identity (5)` is then nonsense. +#[test] +fn a_gap_before_the_angle_is_not_type_application() { + rejected_somehow( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity (5)}}")"#), + ); +} + +// --------------------------------------------------------------------------- +// Positive controls — `<` stays the comparison operator everywhere else +// --------------------------------------------------------------------------- + +/// "Everywhere else `<` is the comparison operator, so `a < b` and +/// `f(a) < g(b)` are unaffected." Green today; must stay green after. +#[test] +fn a_comparison_is_not_type_application() { + accepts( + Flavor::Default, + &format!( + r#"{IDENTITY}fn lower(a, b) = a < b +print("${{toString(lower(1, 2))}} ${{toString(identity(3) < identity(4))}}")"# + ), + ); +} + +/// A parenthesised relational chain keeps working ("must parenthesise"). +#[test] +fn a_parenthesised_relational_chain_still_checks() { + accepts( + Flavor::Default, + r#"let flag = (1 < 2) == true +print("${toString(flag)}")"#, + ); +} + +/// Inference without written arguments is untouched: one binder still serves +/// two instantiations ([TYPE-GENERICS-FN]). +#[test] +fn omitting_type_arguments_still_infers_each_instantiation() { + accepts( + Flavor::Default, + &format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#), + ); +} diff --git a/crates/osprey-types/src/generics_decl_tests.rs b/crates/osprey-types/src/generics_decl_tests.rs new file mode 100644 index 00000000..f7cd8c5b --- /dev/null +++ b/crates/osprey-types/src/generics_decl_tests.rs @@ -0,0 +1,381 @@ +//! Spec-driven assertions for **declared generics**: the binder and the +//! construction site ([TYPE-GENERICS-DECL], [GENERICS-CTOR-ARITY], +//! [TYPE-GENERICS-FN], docs/specs/0004-TypeSystem.md; ML spellings in +//! [FLAVOR-ML-GENERICS], docs/specs/0024-MLFlavorSyntax.md). +//! +//! The call site is stated separately in `generics_apply_tests.rs`; this module +//! covers the two positions that already ship, and the permutations of each +//! sentence the spec writes about them. + +use crate::testutil::{accepts, ctor_arity_message, rejected_somehow, rejects_with}; +use osprey_syntax::Flavor; + +/// One binder, one field. +const BOX: &str = "type Box = { value: T }\n"; +/// Two binders across two fields — order is observable. +const PAIR: &str = "type Pair = { first: T, second: U }\n"; + +// --------------------------------------------------------------------------- +// [TYPE-GENERICS-DECL] — binders span every variant field +// --------------------------------------------------------------------------- + +/// "`type Pair = …` binds `T`/`U` across every variant field." +#[test] +fn a_binder_spans_every_variant_field() { + accepts( + Flavor::Default, + r#"type Holder = Full { left: T, right: U } | Half { only: T } | None +fn label(h: Holder) = match h { + Full { left, right } => right + Half { only } => "half" + None => "none" +} +print(label(Full { left: 1, right: "one" }))"#, + ); +} + +/// One binder used twice in one variant pins both fields to one type. +#[test] +fn one_binder_used_twice_pins_both_fields() { + rejects_with( + Flavor::Default, + r#"type Both = { left: T, right: T } +let b = Both { left: 1, right: "two" } +print("${b.left}")"#, + "cannot unify", + ); +} + +/// "A construction site may apply explicit type arguments … which unify with +/// the instantiation the fields would otherwise infer." +#[test] +fn a_construction_site_may_pin_its_instantiation() { + accepts( + Flavor::Default, + &format!( + r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} +print("${{p.first}}${{p.second}}")"# + ), + ); +} + +/// "an argument that contradicts a field is a type error." +#[test] +fn a_construction_type_argument_contradicting_a_field_is_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{BOX}let b = Box {{ value: "text" }} +print("${{b.value}}")"# + ), + "cannot unify", + ); +} + +/// The contradiction is caught in the second position as well. +#[test] +fn a_contradiction_in_the_second_type_argument_is_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} +print("${{p.first}}")"# + ), + "cannot unify", + ); +} + +/// A nested instantiation is pinned the same way. +#[test] +fn a_nested_construction_type_argument_is_checked() { + accepts( + Flavor::Default, + &format!( + r#"{BOX}let nested = Box> {{ value: Box {{ value: 7 }} }} +print("${{nested.value.value}}")"# + ), + ); +} + +// --------------------------------------------------------------------------- +// [GENERICS-CTOR-ARITY] — the count is a contract with the declaration +// --------------------------------------------------------------------------- + +/// "`Box { v: 1 }` is rejected with `takes 1 type argument(s), got 2`." +#[test] +fn too_many_construction_type_arguments_are_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{BOX}let b = Box {{ value: 1 }} +print("${{b.value}}")"# + ), + &ctor_arity_message("Box", 1, 2), + ); +} + +/// The other direction: two binders, one written argument. +#[test] +fn too_few_construction_type_arguments_are_rejected() { + rejects_with( + Flavor::Default, + &format!( + r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} +print("${{p.first}}")"# + ), + &ctor_arity_message("Pair", 2, 1), + ); +} + +/// A type that declares NO binders accepts no type arguments. +#[test] +fn a_non_generic_type_takes_no_construction_type_arguments() { + rejects_with( + Flavor::Default, + r#"type Plain = { value: int } +let p = Plain { value: 1 } +print("${p.value}")"#, + &ctor_arity_message("Plain", 0, 1), + ); +} + +/// Omitting the arguments entirely stays legal — they are optional, and +/// inference supplies them. +#[test] +fn omitting_construction_type_arguments_still_infers() { + accepts( + Flavor::Default, + &format!( + r#"{BOX}let n = Box {{ value: 1 }} +let s = Box {{ value: "one" }} +print("${{n.value}}${{s.value}}")"# + ), + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-GENERICS-FN] — what a function binder means +// --------------------------------------------------------------------------- + +/// "A binder makes every use of `T` in the signature the SAME inference +/// variable" — so two arguments at different types are rejected. +#[test] +fn one_function_binder_relates_two_parameters() { + accepts( + Flavor::Default, + r#"fn pick(first: T, second: T) -> T = first +print("${pick(10, 20)} ${pick("left", "right")}")"#, + ); + rejects_with( + Flavor::Default, + r#"fn pick(first: T, second: T) -> T = first +print("${pick(10, "twenty")}")"#, + "cannot unify", + ); +} + +/// "without it, `T` in an annotation names a nominal type" — an undeclared +/// nominal name is not a type. +#[test] +fn an_unbound_annotation_name_is_nominal_not_a_binder() { + rejected_somehow( + Flavor::Default, + r#"fn nom(a: T) -> T = a +print("${nom(1)}")"#, + ); +} + +/// …and when that nominal name IS declared, it binds nothing: the function is +/// monomorphic in it. +#[test] +fn a_declared_nominal_name_makes_the_function_monomorphic() { + accepts( + Flavor::Default, + r#"type Tag = { id: int } +fn nom(a: Tag) -> Tag = a +print("${nom(Tag { id: 1 }).id}")"#, + ); + rejects_with( + Flavor::Default, + r#"type Tag = { id: int } +fn nom(a: Tag) -> Tag = a +print("${nom(1)}")"#, + "cannot unify", + ); +} + +/// "HM inference is unchanged: unannotated functions stay implicitly +/// polymorphic." +#[test] +fn an_unannotated_function_stays_implicitly_polymorphic() { + accepts( + Flavor::Default, + r#"fn id(x) = x +print("${id(5)} ${id("os")} ${toString(id(true))}")"#, + ); +} + +/// Two binders are independent: they may be instantiated at the same type or +/// at different ones. +#[test] +fn two_binders_are_independent() { + accepts( + Flavor::Default, + r#"fn pair(first: T, second: U) -> T = first +print("${pair(1, "a")} ${pair(1, 2)}")"#, + ); +} + +/// A binder list names DISTINCT parameters; a repeat has no meaning. +#[test] +fn a_repeated_binder_name_is_rejected() { + rejected_somehow( + Flavor::Default, + r#"fn dup(first: T, second: T) -> T = first +print("${dup(1, 2)}")"#, + ); +} + +/// An empty binder list is not a binder list. +#[test] +fn an_empty_binder_list_is_rejected() { + rejected_somehow( + Flavor::Default, + r#"fn none<>(x) = x +print("${none(1)}")"#, + ); +} + +/// A binder may appear in the return position only — the shape call-site type +/// application exists to serve ([TYPE-GENERICS-APPLY]). +#[test] +fn a_binder_may_appear_in_the_return_position_only() { + accepts( + Flavor::Default, + r#"fn empty() -> List = [] +let held: List = empty() +print("${length(held)}")"#, + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-GENERICS-FN] — a generic function as a VALUE +// --------------------------------------------------------------------------- + +/// "specialised wherever its ABI can be fixed: by a consuming slot, by a call +/// alias" — the alias form. +#[test] +fn a_generic_function_binds_as_a_call_alias() { + accepts( + Flavor::Default, + r#"fn identity(x: T) -> T = x +let g = identity +print("${g(5)} ${g("os")}")"#, + ); +} + +/// …and the consuming-slot form: a generic function passed by name to a HOF. +#[test] +fn a_generic_function_specialises_into_a_consuming_slot() { + accepts( + Flavor::Default, + r#"fn identity(x: T) -> T = x +fn also(x, f) = f(x) +print("${also(5, identity)} ${also("os", identity)}")"#, + ); +} + +/// "`fn pick() = |x| => x` followed by `let f = pick()` therefore serves +/// `f(7)`, `f("os")` and `f(2.5)` from one binding." +#[test] +fn a_returned_generic_lambda_serves_every_call_site_of_its_binding() { + accepts( + Flavor::Default, + r#"fn mk() = |x| => x +let f = mk() +print("${f(7)} ${f("os")} ${f(2.5)}")"#, + ); +} + +/// "A lambda so returned may close over the producing call's parameters." +#[test] +fn a_returned_lambda_may_close_over_the_producing_call() { + accepts( + Flavor::Default, + r#"fn constly(v) = |x| => v +let always = constly(9) +print("${always(1)} ${always("os")}")"#, + ); +} + +/// "a still-generic lambda used as a bare value … is rejected rather than +/// guessed", with the compiler's own sentence. +#[test] +fn a_still_generic_lambda_as_a_bare_value_is_rejected() { + rejects_with( + Flavor::Default, + r#"fn mk(x) = |y| => x +print("${mk(1)}")"#, + "a closure value with a still-generic type", + ); +} + +// --------------------------------------------------------------------------- +// [FLAVOR-ML-GENERICS] — the ML spellings of the same declarations +// --------------------------------------------------------------------------- + +/// "Types use juxtaposed binders: `type Box T`." +#[test] +fn ml_type_binders_are_juxtaposed() { + accepts( + Flavor::Ml, + "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", + ); +} + +/// "Construction-site type arguments use `Box(item = 7)`." +#[test] +fn ml_construction_type_arguments_use_angles() { + accepts( + Flavor::Ml, + "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", + ); +} + +/// The ML construction site is held to the same arity contract. +#[test] +fn ml_construction_type_argument_arity_is_checked() { + rejects_with( + Flavor::Ml, + "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", + &ctor_arity_message("Box", 1, 2), + ); +} + +/// "Function binders appear on a signature: `pick : (T, T) -> T`." +#[test] +fn ml_function_binders_live_on_the_signature() { + accepts( + Flavor::Ml, + "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n", + ); +} + +/// "A binding without a signature cannot declare function type parameters." +#[test] +fn ml_a_binding_cannot_declare_type_parameters_without_a_signature() { + rejected_somehow( + Flavor::Ml, + "pick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n", + ); +} + +/// The ML twin of the one-binder-relates-two-parameters rule. +#[test] +fn ml_one_binder_relates_two_parameters() { + rejects_with( + Flavor::Ml, + "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, \"twenty\")\nprint \"${kept}\"\n", + "cannot unify", + ); +} diff --git a/crates/osprey-types/src/generics_variance_tests.rs b/crates/osprey-types/src/generics_variance_tests.rs new file mode 100644 index 00000000..1f098e39 --- /dev/null +++ b/crates/osprey-types/src/generics_variance_tests.rs @@ -0,0 +1,350 @@ +//! Spec-driven assertions for **declaration-site variance** +//! ([TYPE-VARIANCE-DECL], [TYPE-VARIANCE-POSITIONS], [TYPE-VARIANCE-ASSIGN], +//! docs/specs/0004-TypeSystem.md). +//! +//! Position checking is the crisp half: "fields and function results are OUTPUT +//! positions; function parameters flip the polarity (INPUT); a nested +//! constructor's argument composes the position with that constructor's +//! declared variance". Every composition below is one row of that rule, and the +//! built-in variance table (`Result`, `List`, +//! `Fiber`, `Map`, invariant `Channel`) is checked THROUGH +//! it — a wrong entry in that table shows up as a position that should have +//! been rejected and was not. + +use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position_message}; +use osprey_syntax::Flavor; + +/// The position diagnostic for a type declaration's FIELD. +fn position_message(param: &str, marker: &str, position: &str, field: &str, owner: &str) -> String { + variance_position_message(param, marker, position, "field", field, owner) +} + +/// A one-field record declaration, the smallest carrier of a position. +fn decl(params: &str, field: &str, ty: &str) -> String { + format!("type Holder{params} = {{ {field}: {ty} }}\nprint(\"declared\")") +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-POSITIONS] — output positions +// --------------------------------------------------------------------------- + +/// A field is an OUTPUT position, so `out T` belongs there. +#[test] +fn out_is_legal_in_a_field() { + accepts(Flavor::Default, &decl("", "supply", "T")); +} + +/// A function RESULT is an output position, so `out T` belongs there too. +#[test] +fn out_is_legal_in_a_function_result() { + accepts(Flavor::Default, &decl("", "make", "(int) -> T")); +} + +/// A function PARAMETER flips the polarity to input: `out T` is rejected. +#[test] +fn out_in_a_function_parameter_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "consume", "(T) -> int"), + &position_message("T", "out", "input", "consume", "Holder"), + ); +} + +/// Two flips compose back to an output position, so `out T` is legal again. +#[test] +fn out_under_two_parameter_flips_is_legal() { + accepts(Flavor::Default, &decl("", "hof", "((T) -> int) -> int")); +} + +/// An `in` parameter belongs in an input position. +#[test] +fn in_is_legal_in_a_function_parameter() { + accepts(Flavor::Default, &decl("", "admit", "(T) -> bool")); +} + +/// A field is an output position, so `in T` is rejected there. +#[test] +fn in_in_a_field_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "held", "T"), + &position_message("T", "in", "output", "held", "Holder"), + ); +} + +/// A function result is an output position, so `in T` is rejected there. +#[test] +fn in_in_a_function_result_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "make", "(int) -> T"), + &position_message("T", "in", "output", "make", "Holder"), + ); +} + +/// Two flips compose back to output, so `in T` is rejected under them. +#[test] +fn in_under_two_parameter_flips_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "hof", "((T) -> int) -> int"), + &position_message("T", "in", "output", "hof", "Holder"), + ); +} + +/// An unannotated parameter is invariant and sits in EITHER position. +#[test] +fn an_invariant_parameter_is_legal_in_both_positions() { + accepts(Flavor::Default, &decl("", "held", "T")); + accepts(Flavor::Default, &decl("", "consume", "(T) -> int")); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-POSITIONS] — composition through a nested constructor +// --------------------------------------------------------------------------- + +/// A covariant argument of a covariant constructor keeps the position. +#[test] +fn out_inside_a_covariant_constructor_argument_is_legal() { + accepts( + Flavor::Default, + &format!("type Feed = {{ supply: A }}\n{}", decl("", "nested", "Feed")), + ); +} + +/// A covariant argument of a CONTRAVARIANT constructor flips the position. +#[test] +fn out_inside_a_contravariant_constructor_argument_is_rejected() { + rejects_with( + Flavor::Default, + &format!("type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate")), + &position_message("T", "out", "input", "nested", "Holder"), + ); +} + +/// The mirror: `in T` inside a contravariant argument lands in output. +#[test] +fn in_inside_a_contravariant_constructor_argument_is_rejected() { + rejects_with( + Flavor::Default, + &format!("type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate")), + &position_message("T", "in", "output", "nested", "Holder"), + ); +} + +/// "an invariant argument position demands both directions, so only invariant +/// parameters may sit there" — a covariant parameter may not. +#[test] +fn out_inside_an_invariant_constructor_argument_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + ); +} + +/// …nor may a contravariant one. +#[test] +fn in_inside_an_invariant_constructor_argument_is_rejected() { + rejected_somehow( + Flavor::Default, + &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + ); +} + +/// An invariant parameter is exactly what an invariant argument accepts. +#[test] +fn an_invariant_parameter_inside_an_invariant_argument_is_legal() { + accepts( + Flavor::Default, + &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-ASSIGN] — the built-in variance table, checked by position +// --------------------------------------------------------------------------- + +/// `List`: a covariant parameter may sit in its argument. +#[test] +fn list_is_covariant_in_its_element() { + accepts(Flavor::Default, &decl("", "items", "List")); +} + +/// `Result`: both arguments are covariant. +#[test] +fn result_is_covariant_in_both_arguments() { + accepts(Flavor::Default, &decl("", "value", "Result")); + accepts(Flavor::Default, &decl("", "failure", "Result")); +} + +/// `Fiber`: covariant in its answer. +#[test] +fn fiber_is_covariant_in_its_answer() { + accepts(Flavor::Default, &decl("", "worker", "Fiber")); +} + +/// `Map`: the VALUE is covariant. +#[test] +fn map_is_covariant_in_its_value() { + accepts(Flavor::Default, &decl("", "byName", "Map")); +} + +/// `Map`: the KEY is invariant, so a covariant parameter is rejected. +#[test] +fn map_keys_are_invariant() { + rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); +} + +/// `Channel` is invariant in both directions. +#[test] +fn channel_is_invariant() { + rejected_somehow(Flavor::Default, &decl("", "wire", "Channel")); + rejected_somehow(Flavor::Default, &decl("", "wire", "Channel")); +} + +/// A `List` of a contravariant parameter is an output position. +#[test] +fn in_inside_a_list_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "items", "List"), + &position_message("T", "in", "output", "items", "Holder"), + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-ASSIGN] — leaves match exactly, in every container +// --------------------------------------------------------------------------- + +/// A `Result` payload is never extracted under a container, whatever the +/// declared variance: the stored representation differs. +fn feed_payload_program(marker: &str) -> String { + format!( + r#"type Feed<{marker}T> = Feed {{ supply: T }} | Dry +fn firstItem(f: Feed) = match f {{ + Feed {{ supply }} => supply + Dry => 0 +}} +fn mkFeed() -> Feed> = Feed {{ supply: 20 * 5 }} +print("${{firstItem(mkFeed())}}")"# + ) +} + +/// Under `out T`. +#[test] +fn a_result_payload_does_not_collapse_under_a_covariant_container() { + rejects_with(Flavor::Default, &feed_payload_program("out "), "cannot unify"); +} + +/// Under an invariant parameter. +#[test] +fn a_result_payload_does_not_collapse_under_an_invariant_container() { + rejects_with(Flavor::Default, &feed_payload_program(""), "cannot unify"); +} + +/// "Function returns also match exactly, so a `Feed<(int) -> Result>` +/// does not match a `Feed<(int) -> int>` slot" — the spec's own example. +#[test] +fn a_function_payloads_return_channel_matches_exactly() { + rejects_with( + Flavor::Default, + r#"type Feed = Feed { supply: T } | Dry +fn label(f: Feed<(int) -> int>) = match f { + Feed { supply } => "supplied" + Dry => "dry" +} +fn mkFeed() -> Feed<(int) -> Result> = Feed { supply: |n| => n * 2 } +print(label(mkFeed()))"#, + "cannot unify", + ); +} + +/// The direct value site keeps the one safe promotion `T -> Result`, +/// which is what makes the container rejections above a real restriction rather +/// than a blanket ban. +#[test] +fn the_direct_site_promotion_still_holds() { + accepts( + Flavor::Default, + r#"fn keep(n: Result) = n ?: 0 +print("${keep(5)}")"#, + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-DECL] — where the markers may be written at all +// --------------------------------------------------------------------------- + +/// "`out` and `in` are contextual keywords, reserved only inside +/// type-parameter lists" — they stay usable as ordinary names. +#[test] +fn out_and_in_stay_legal_identifiers_outside_a_parameter_list() { + accepts( + Flavor::Default, + r#"let out = 1 +let inn = 2 +fn keep(out) = out +print("${keep(out)} ${inn}")"#, + ); +} + +/// Variance is declaration-site on TYPES and EFFECTS only — never on a +/// function binder ([TYPE-GENERICS-FN]). +#[test] +fn a_variance_marker_on_a_function_binder_is_rejected() { + rejects_with( + Flavor::Default, + r#"fn pick(first: T, second: T) -> T = first +print("${pick(1, 2)}")"#, + "variance annotations are only valid on type and effect declarations", + ); + rejects_with( + Flavor::Default, + r#"fn pick(first: T, second: T) -> T = first +print("${pick(1, 2)}")"#, + "variance annotations are only valid on type and effect declarations", + ); +} + +// --------------------------------------------------------------------------- +// [FLAVOR-ML-GENERICS] — the same rules through the ML spellings +// --------------------------------------------------------------------------- + +/// "Types use juxtaposed binders: `type Box T`, `type Feed out T`, +/// `type Sink in T`." +#[test] +fn ml_variance_binders_check_the_same_positions() { + accepts( + Flavor::Ml, + "type Feed out T =\n supply : T\nprint \"declared\"\n", + ); + rejects_with( + Flavor::Ml, + "type Bad out T =\n consume : T -> int\nprint \"declared\"\n", + &position_message("T", "out", "input", "consume", "Bad"), + ); +} + +/// The ML twin of the contravariant rules. +#[test] +fn ml_contravariant_binders_check_the_same_positions() { + accepts( + Flavor::Ml, + "type Gate in T =\n admit : T -> bool\nprint \"declared\"\n", + ); + rejects_with( + Flavor::Ml, + "type Bad in T =\n held : T\nprint \"declared\"\n", + &position_message("T", "in", "output", "held", "Bad"), + ); +} + +/// ML function binders reject variance exactly as Default's do. +#[test] +fn ml_a_variance_marker_on_a_function_binder_is_rejected() { + rejects_with( + Flavor::Ml, + "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (1, 2)\nprint \"${kept}\"\n", + "variance annotations are only valid on type and effect declarations", + ); +} diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index 0d619d10..8454821a 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -29,6 +29,16 @@ mod effect_rows_tests; mod env; mod error; mod expr; +#[cfg(test)] +mod generic_effects_tests; +#[cfg(test)] +mod generics_apply_ml_tests; +#[cfg(test)] +mod generics_apply_tests; +#[cfg(test)] +mod generics_decl_tests; +#[cfg(test)] +mod generics_variance_tests; mod info; mod init_order; mod multiplicity; diff --git a/crates/osprey-types/src/testutil.rs b/crates/osprey-types/src/testutil.rs index 82c91361..799095e0 100644 --- a/crates/osprey-types/src/testutil.rs +++ b/crates/osprey-types/src/testutil.rs @@ -7,24 +7,29 @@ use crate::check::check_program; use crate::error::TypeError; -use osprey_syntax::parse_program; +use osprey_syntax::{parse_program_with_flavor, Flavor}; -/// Parse + type-check a snippet, returning the diagnostics. Panics if the -/// snippet has syntax errors, since those would mask the type-checking intent. -pub(crate) fn check(src: &str) -> Vec { - let parsed = parse_program(src); +/// Parse under `flavor` + type-check, returning the diagnostics. Panics if the +/// snippet has syntax errors, since a program that never reaches the checker +/// must not be scored as "no type errors". +pub(crate) fn typecheck(flavor: Flavor, src: &str) -> Vec { + let parsed = parse_program_with_flavor(src, flavor); assert!( parsed.errors.is_empty(), - "syntax errors: {:?}", + "{flavor} flavor rejected the snippet at parse time: {:?}\n{src}", parsed.errors ); check_program(&parsed.program) } +/// Parse + type-check a Default-flavor snippet, returning the diagnostics. +pub(crate) fn check(src: &str) -> Vec { + typecheck(Flavor::Default, src) +} + /// Parse + type-check, asserting the snippet is well-typed (no diagnostics). pub(crate) fn ok(src: &str) { - let errs = check(src); - assert!(errs.is_empty(), "unexpected type errors: {errs:?}"); + accepts(Flavor::Default, src); } /// Parse + type-check, asserting at least one type error is reported. @@ -33,3 +38,60 @@ pub(crate) fn bad(src: &str) -> Vec { assert!(!errs.is_empty(), "expected a type error, got none"); errs } + +/// Assert `src` is accepted whole under `flavor`: parsed AND well-typed. +pub(crate) fn accepts(flavor: Flavor, src: &str) { + let errs = typecheck(flavor, src); + assert!( + errs.is_empty(), + "{flavor}: unexpected type errors: {errs:?}\n{src}" + ); +} + +/// Assert the CHECKER rejects `src` with a diagnostic containing `needle`. A +/// rejection for any other reason — a syntax error included — fails the test, +/// so a feature that is merely unparseable can never masquerade as checked. +pub(crate) fn rejects_with(flavor: Flavor, src: &str, needle: &str) { + let errs = typecheck(flavor, src); + assert!( + errs.iter().any(|e| e.message.contains(needle)), + "{flavor}: expected a diagnostic containing {needle:?}, got {errs:?}\n{src}" + ); +} + +/// Assert `src` is rejected SOMEHOW — by the parser or by the checker. Used +/// where the spec forbids a form without fixing which layer must catch it. +pub(crate) fn rejected_somehow(flavor: Flavor, src: &str) { + let parsed = parse_program_with_flavor(src, flavor); + let rejected = !parsed.errors.is_empty() || !check_program(&parsed.program).is_empty(); + assert!(rejected, "{flavor}: expected a rejection, got none\n{src}"); +} + +/// The call-site arity contract's exact wording, mirroring +/// [GENERICS-CTOR-ARITY]'s `constructor \`Box\` takes 1 type argument(s), got 2`. +pub(crate) fn fn_arity_message(name: &str, declared: usize, written: usize) -> String { + format!("function `{name}` takes {declared} type argument(s), got {written}") +} + +/// The construction-site arity wording ([GENERICS-CTOR-ARITY]). +pub(crate) fn ctor_arity_message(name: &str, declared: usize, written: usize) -> String { + format!("constructor `{name}` takes {declared} type argument(s), got {written}") +} + +/// The declaration-site variance diagnostic, from +/// `examples/failscompilation/variance_out_in_input_position.ospo`. `kind` is +/// `field` for a type declaration and `operation` for an effect declaration +/// ([TYPE-VARIANCE-POSITIONS], [EFFECTS-GENERIC-DECL]). +pub(crate) fn variance_position_message( + param: &str, + marker: &str, + position: &str, + kind: &str, + name: &str, + owner: &str, +) -> String { + format!( + "type parameter `{param}` is declared `{marker} {param}` but appears in \ + {position} position in {kind} `{name}` of `{owner}`" + ) +} diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index 612acde7..e6f5bd75 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -211,7 +211,14 @@ Remaining: - [ ] **Call-site type application** `identity(5)` — grammar + `Expr::Call.type_args` + both-flavor lowering + checker unification - (§What-is-left 1). + (§What-is-left 1). **Specified and pinned red first**: the contract is + [spec 0004](../specs/0004-TypeSystem.md) `[TYPE-GENERICS-APPLY]` and + [spec 0024](../specs/0024-MLFlavorSyntax.md) `[FLAVOR-ML-GENERICS]`; the + failing assertions are `crates/osprey-types/src/generics_apply_tests.rs` + (Default), `generics_apply_ml_tests.rs` (ML), four CST cases in + `tree-sitter-osprey/test/corpus/osprey.txt`, and the corpus twins + `tests/regressions/basics/types/type_equality_comprehensive.test.osp{,ml}` + with the golden line `applied int=5 text=os nested=2 empty=0 pair=7`. - [x] **Generic functions as values** — landed via plan 0002, now retired; the shipped contract is [spec 0004](../specs/0004-TypeSystem.md) `[TYPE-GENERICS-FN]`: slot-driven specialization + let-alias + inline fn-typed arg @@ -222,5 +229,16 @@ Remaining: instantiation mismatch a compile error; explicit rows are contracts, and the runtime null guard is only a backstop (§What-is-left 3 and [plan 0016](0016-algebraic-effects-and-handlers.md)). -- [ ] failscompilation case for turbofish once it lands (arity/instantiation - mismatch at the call site). +- [ ] failscompilation cases for turbofish once it lands — already written and + red: `turbofish_type_arg_arity`, `turbofish_type_arg_too_few`, + `turbofish_no_declared_binder`, `turbofish_argument_contradiction`, + `turbofish_variance_marker`, `ml_turbofish_type_arg_arity` and + `ml_turbofish_no_declared_binder` in `examples/failscompilation/`. +- [ ] The adjacent spec surface is pinned by the same sweep and may expose + defects of its own: `generics_decl_tests.rs` + ([TYPE-GENERICS-DECL], [GENERICS-CTOR-ARITY], [TYPE-GENERICS-FN]), + `generics_variance_tests.rs` ([TYPE-VARIANCE-*], including the built-in + variance table checked through position composition) and + `generic_effects_tests.rs` ([EFFECTS-GENERIC-*], plus the + `handle … do` spelling spec 0017 writes and the language does not accept — + [plan 0027](0027-arithmetic-effects.md) phase 0 owns that rename). diff --git a/docs/specs/0003-Syntax.md b/docs/specs/0003-Syntax.md index 73511e7e..6101330f 100644 --- a/docs/specs/0003-Syntax.md +++ b/docs/specs/0003-Syntax.md @@ -235,6 +235,28 @@ let zero = fn() => 0 The pipe-delimited form requires at least one parameter because `||` is the logical-OR token. +### Call-site type arguments [TYPE-GENERICS-APPLY] + +A call may carry an explicit type-argument list between the callee and its +arguments. The list is recognised only when the `<` immediately follows the +callee name and the matching `>` immediately precedes the argument list, which +is what keeps `<` the comparison operator everywhere else. + +```ebnf +call ::= callee typeArguments? "(" arguments? ")" +typeArguments ::= "<" typeList ">" +``` + +```osprey +fn identity(x: T) -> T = x +print("${identity(5)}") +``` + +The meaning — positional binding against the declaration's binders, the arity +contract, and the rejection of variance markers — is +[TYPE-GENERICS-APPLY](0004-TypeSystem.md#generics-and-variance). The ML spelling +is [FLAVOR-ML-GENERICS](0024-MLFlavorSyntax.md#generics-flavor-ml-generics). + ## Indexing Postfix indexing is available on lists, maps, and strings. It returns diff --git a/docs/specs/0004-TypeSystem.md b/docs/specs/0004-TypeSystem.md index 40dcdb06..750cd705 100644 --- a/docs/specs/0004-TypeSystem.md +++ b/docs/specs/0004-TypeSystem.md @@ -195,6 +195,47 @@ s = pick ("left", "right") In the ML flavor the binder lives on the signature line (`pick : …`); a binding without a signature cannot declare type parameters. +`[TYPE-GENERICS-APPLY]` **A call site may apply type arguments explicitly.** +`identity(5)` pins the callee's declared binders positionally, left to +right, and the written arguments unify with the instantiation the value +arguments and the expected type would otherwise infer. This is the direct +spelling of what an annotated binding (`let x: int = identity(5)`) can only say +indirectly, and the only spelling that can pin a binder appearing in no +parameter position. + +```osprey +fn identity(x: T) -> T = x +fn pick(first: T, second: U) -> T = first +print("${identity(5)} ${pick(1, "two")}") +``` + +```osprey-ml +identity : T -> T +identity x = x +print "${identity 5}" +``` + +The form is recognised when the `<` immediately follows the callee name and the +matching `>` immediately precedes the call's argument list — `(` in the Default +flavor, the juxtaposed argument in ML. Everywhere else `<` is the comparison +operator, so `a < b` and `f(a) < g(b)` are unaffected; a relational chain that +would otherwise read as type application must parenthesise. + +Applying type arguments is a contract with the declaration, checked the same way +[GENERICS-CTOR-ARITY] checks a construction site: + +- The count must equal the callee's declared binder count. `identity(5)` + against `fn identity` is rejected with + `function \`identity\` takes 1 type argument(s), got 2`. +- A callee that declares no binders — an unannotated function, a lambda, a + parameter holding a function value — takes no type arguments, and is rejected + with the same diagnostic at count 0. +- A written argument that contradicts the value arguments or the expected type is + a type error, not a silently ignored annotation: `identity("text")` + reports `cannot unify int with string`. +- Variance markers are not permitted, exactly as on the binder itself + ([TYPE-VARIANCE-DECL]): `identity(5)` is rejected. + A generic function used as a VALUE is specialised wherever its ABI can be fixed: by a consuming slot, by a call alias, or — when a generic function returns a lambda — at each call site of the binding, which is inlined and diff --git a/docs/specs/0005-FunctionCalls.md b/docs/specs/0005-FunctionCalls.md index 4de8777b..00044ac5 100644 --- a/docs/specs/0005-FunctionCalls.md +++ b/docs/specs/0005-FunctionCalls.md @@ -5,6 +5,15 @@ uncurried grouping lower to the same node shapes as described in [FLAVOR-CURRY](0023-LanguageFlavors.md#currying-canonicalisation) and [FLAVOR-ML-CALL](0024-MLFlavorSyntax.md). +## Type arguments [TYPE-GENERICS-APPLY] + +A call to a function that declares type parameters may pin them at the call +site: `identity(5)`, ML `identity 5`. The written list is positional, +must match the declared binder count, and is checked against the instantiation +the value arguments infer — the full contract is +[TYPE-GENERICS-APPLY](0004-TypeSystem.md#generics-and-variance), the grammar is +[0003 §Call-site type arguments](0003-Syntax.md#call-site-type-arguments--type-generics-apply). + ## Argument forms [CALL-ARGUMENTS] Default accepts positional calls at every arity: diff --git a/docs/specs/0024-MLFlavorSyntax.md b/docs/specs/0024-MLFlavorSyntax.md index 2d62b185..4fbb721f 100644 --- a/docs/specs/0024-MLFlavorSyntax.md +++ b/docs/specs/0024-MLFlavorSyntax.md @@ -272,6 +272,9 @@ Generic declarations lower to the same variance-carrying `TypeParam` and - Effect rows apply arguments with angles: `! Stash` or `! [Read, Write]`. - Construction-site type arguments use `Box(item = 7)`. +- Call-site type arguments attach to the callee name and precede the juxtaposed + argument: `identity 5`, `pick (1, "two")` + ([TYPE-GENERICS-APPLY](0004-TypeSystem.md#generics-and-variance)). Function binders do not accept variance. A binding without a signature cannot declare function type parameters. diff --git a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo new file mode 100644 index 00000000..ebe6a166 --- /dev/null +++ b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo @@ -0,0 +1,8 @@ +(** A binding without a signature cannot declare type parameters, so it cannot + be applied at a call site either. + Implements [TYPE-GENERICS-APPLY], [FLAVOR-ML-GENERICS] *) +plain x = x + +main () = + pinned = plain 5 + print "${pinned}" diff --git a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput new file mode 100644 index 00000000..1ed7260c --- /dev/null +++ b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput @@ -0,0 +1 @@ +7:13: function `plain` takes 0 type argument(s), got 1 diff --git a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo new file mode 100644 index 00000000..41867cc0 --- /dev/null +++ b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo @@ -0,0 +1,9 @@ +(** The ML surface applies call-site type arguments with the same angles and is + held to the same count contract — one shared core, two spellings. + Implements [TYPE-GENERICS-APPLY], [FLAVOR-ML-GENERICS] *) +identity : T -> T +identity x = x + +main () = + pinned = identity 5 + print "${pinned}" diff --git a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput new file mode 100644 index 00000000..73b9aa34 --- /dev/null +++ b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput @@ -0,0 +1 @@ +8:13: function `identity` takes 1 type argument(s), got 2 diff --git a/examples/failscompilation/turbofish_argument_contradiction.ospo b/examples/failscompilation/turbofish_argument_contradiction.ospo new file mode 100644 index 00000000..25b66207 --- /dev/null +++ b/examples/failscompilation/turbofish_argument_contradiction.ospo @@ -0,0 +1,9 @@ +// A written type argument is checked, not decorative: it unifies with the +// instantiation the value arguments infer, so a contradiction is a type error. +// Implements [TYPE-GENERICS-APPLY] +fn identity(x: T) -> T = x + +fn main() -> Unit = { + let pinned = identity("text") + print("${pinned}") +} diff --git a/examples/failscompilation/turbofish_argument_contradiction.ospo.expectedoutput b/examples/failscompilation/turbofish_argument_contradiction.ospo.expectedoutput new file mode 100644 index 00000000..31079bc4 --- /dev/null +++ b/examples/failscompilation/turbofish_argument_contradiction.ospo.expectedoutput @@ -0,0 +1 @@ +type mismatch: cannot unify int with string diff --git a/examples/failscompilation/turbofish_no_declared_binder.ospo b/examples/failscompilation/turbofish_no_declared_binder.ospo new file mode 100644 index 00000000..63271697 --- /dev/null +++ b/examples/failscompilation/turbofish_no_declared_binder.ospo @@ -0,0 +1,10 @@ +// An unannotated function is implicitly polymorphic, which is NOT a declared +// binder: there is nothing for a written type argument to pin, so the call is +// rejected rather than silently ignoring the annotation. +// Implements [TYPE-GENERICS-APPLY], [TYPE-GENERICS-FN] +fn plain(x) = x + +fn main() -> Unit = { + let pinned = plain(5) + print("${pinned}") +} diff --git a/examples/failscompilation/turbofish_no_declared_binder.ospo.expectedoutput b/examples/failscompilation/turbofish_no_declared_binder.ospo.expectedoutput new file mode 100644 index 00000000..0d7f3748 --- /dev/null +++ b/examples/failscompilation/turbofish_no_declared_binder.ospo.expectedoutput @@ -0,0 +1 @@ +8:17: function `plain` takes 0 type argument(s), got 1 diff --git a/examples/failscompilation/turbofish_type_arg_arity.ospo b/examples/failscompilation/turbofish_type_arg_arity.ospo new file mode 100644 index 00000000..0f727aff --- /dev/null +++ b/examples/failscompilation/turbofish_type_arg_arity.ospo @@ -0,0 +1,9 @@ +// A call site's type arguments are a contract with the declaration: the count +// must equal the declared binder count, exactly as a construction site's does. +// Implements [TYPE-GENERICS-APPLY], [GENERICS-CTOR-ARITY] +fn identity(x: T) -> T = x + +fn main() -> Unit = { + let pinned = identity(5) + print("${pinned}") +} diff --git a/examples/failscompilation/turbofish_type_arg_arity.ospo.expectedoutput b/examples/failscompilation/turbofish_type_arg_arity.ospo.expectedoutput new file mode 100644 index 00000000..b900bfce --- /dev/null +++ b/examples/failscompilation/turbofish_type_arg_arity.ospo.expectedoutput @@ -0,0 +1 @@ +7:17: function `identity` takes 1 type argument(s), got 2 diff --git a/examples/failscompilation/turbofish_type_arg_too_few.ospo b/examples/failscompilation/turbofish_type_arg_too_few.ospo new file mode 100644 index 00000000..6a5a179f --- /dev/null +++ b/examples/failscompilation/turbofish_type_arg_too_few.ospo @@ -0,0 +1,9 @@ +// The count contract binds in both directions: two declared binders demand two +// written arguments, since a partially written list has no meaning. +// Implements [TYPE-GENERICS-APPLY] +fn pick(first: T, second: U) -> T = first + +fn main() -> Unit = { + let kept = pick(1, "two") + print("${kept}") +} diff --git a/examples/failscompilation/turbofish_type_arg_too_few.ospo.expectedoutput b/examples/failscompilation/turbofish_type_arg_too_few.ospo.expectedoutput new file mode 100644 index 00000000..5bfad242 --- /dev/null +++ b/examples/failscompilation/turbofish_type_arg_too_few.ospo.expectedoutput @@ -0,0 +1 @@ +7:15: function `pick` takes 2 type argument(s), got 1 diff --git a/examples/failscompilation/turbofish_variance_marker.ospo b/examples/failscompilation/turbofish_variance_marker.ospo new file mode 100644 index 00000000..2726012a --- /dev/null +++ b/examples/failscompilation/turbofish_variance_marker.ospo @@ -0,0 +1,9 @@ +// Variance is declaration-site on types and effects only. A call site pins an +// instantiation; it does not declare one, so a marker there has no meaning. +// Implements [TYPE-GENERICS-APPLY], [TYPE-VARIANCE-DECL] +fn identity(x: T) -> T = x + +fn main() -> Unit = { + let pinned = identity(5) + print("${pinned}") +} diff --git a/examples/failscompilation/turbofish_variance_marker.ospo.expectedoutput b/examples/failscompilation/turbofish_variance_marker.ospo.expectedoutput new file mode 100644 index 00000000..0c80ffaa --- /dev/null +++ b/examples/failscompilation/turbofish_variance_marker.ospo.expectedoutput @@ -0,0 +1 @@ +7:17: variance annotations are only valid on type and effect declarations; remove the marker from `int` at the call to `identity` diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.osp b/tests/regressions/basics/types/type_equality_comprehensive.test.osp index b4e24e5d..86ed8a3e 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.osp +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.osp @@ -112,6 +112,23 @@ fn mkGate() -> Gate<(int) -> Result> = Gate { admit: |f| => true print("fn-payload feed accepted: ${label(mkFeed())}") print("fn-payload gate accepted: ${describe(mkGate())}") +/// --- Call-site type application: pinning an instantiation in the source --- +/// A written type-argument list pins the callee's declared binders left to +/// right and is checked against what the value arguments infer. `emptyOf`'s +/// binder appears in NO parameter position, so nothing but the written +/// argument can pin it, and `identityOf>` closes two argument lists +/// with one `>>`. Implements [TYPE-GENERICS-APPLY] +fn identityOf(x: T) -> T = x +fn emptyOf() -> List = [] +fn pickOf(first: T, second: U) -> T = first + +let appliedInt = identityOf(5) +let appliedText = identityOf("os") +let appliedNested = length(identityOf>([1, 2])) +let appliedEmpty = length(emptyOf()) +let appliedPair = pickOf(7, "seven") +print("applied int=${appliedInt} text=${appliedText} nested=${appliedNested} empty=${appliedEmpty} pair=${appliedPair}") + print("=== TYPE EQUALITY COMPLETE ===") /// Verifies generic records, function shapes, union tags, and variant payload types. @@ -138,7 +155,12 @@ fn typeEqualityCase() = { !(sameColor(a: Red, b: Blue)), colorName(Green) == "green", label(mkFeed()) == "supplied", - describe(mkGate()) == "guarded" + describe(mkGate()) == "guarded", + identityOf(5) == 5, + identityOf("os") == "os", + length(identityOf>([1, 2])) == 2, + length(emptyOf()) == 0, + pickOf(7, "seven") == 7 ]) } test("equivalent type shapes compose while union tags remain distinct", typeEqualityCase) diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput b/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput index b615c5df..cc6f4b2f 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput @@ -25,6 +25,7 @@ sameRR=true sameRB=false fn-payload feed accepted: supplied fn-payload gate accepted: guarded +applied int=5 text=os nested=2 empty=0 pair=7 === TYPE EQUALITY COMPLETE === ok 1 - equivalent type shapes compose while union tags remain distinct 1..1 diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml index 8db81707..80e8c869 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml @@ -136,6 +136,26 @@ mkGate () = Gate(admit = \f => true) print "fn-payload feed accepted: ${label (mkFeed ())}" print "fn-payload gate accepted: ${describe (mkGate ())}" +(** --- Call-site type application: pinning an instantiation in the source --- + A written type-argument list pins the callee's declared binders left to + right and is checked against what the value arguments infer. `emptyOf`'s + binder appears in NO parameter position, so nothing but the written + argument can pin it, and `identityOf>` closes two argument lists + with one `>>`. Implements [TYPE-GENERICS-APPLY], [FLAVOR-ML-GENERICS] *) +identityOf : T -> T +identityOf x = x +emptyOf : Unit -> List +emptyOf () = [] +pickOf : (T, U) -> T +pickOf (first, second) = first + +appliedInt = identityOf 5 +appliedText = identityOf "os" +appliedNested = length (identityOf> [1, 2]) +appliedEmpty = length (emptyOf ()) +appliedPair = pickOf (7, "seven") +print "applied int=${appliedInt} text=${appliedText} nested=${appliedNested} empty=${appliedEmpty} pair=${appliedPair}" + print "=== TYPE EQUALITY COMPLETE ===" (** Verify generic records, function shapes, union tags, and variant payload types. *) @@ -162,6 +182,11 @@ typeEqualityCase () = !(sameColor (Red, Blue)), colorName Green == "green", label (mkFeed ()) == "supplied", - describe (mkGate ()) == "guarded" + describe (mkGate ()) == "guarded", + identityOf 5 == 5, + identityOf "os" == "os", + length (identityOf> [1, 2]) == 2, + length (emptyOf ()) == 0, + pickOf (7, "seven") == 7 ] test "equivalent type shapes compose while union tags remain distinct" typeEqualityCase diff --git a/tree-sitter-osprey/test/corpus/osprey.txt b/tree-sitter-osprey/test/corpus/osprey.txt index 7d87f8eb..93d8dbc5 100644 --- a/tree-sitter-osprey/test/corpus/osprey.txt +++ b/tree-sitter-osprey/test/corpus/osprey.txt @@ -597,3 +597,117 @@ in perform Signal.read() (type_identifier (identifier)))) operation: (identifier))))))))) + +================================================================================ +Call-site type application [TYPE-GENERICS-APPLY] +================================================================================ + +fn main() = identity(5) + +-------------------------------------------------------------------------------- + +(source_file + (statement + (function_declaration + name: (identifier) + body: (expression + (call_expression + callee: (expression + (primary_expression + (identifier))) + type_arguments: (type_arguments + (type_list + (type_identifier + (identifier)))) + (argument_list + (expression + (primary_expression + (literal + (integer)))))))))) + +================================================================================ +Call-site type application with two arguments [TYPE-GENERICS-APPLY] +================================================================================ + +fn main() = pick(1, "two") + +-------------------------------------------------------------------------------- + +(source_file + (statement + (function_declaration + name: (identifier) + body: (expression + (call_expression + callee: (expression + (primary_expression + (identifier))) + type_arguments: (type_arguments + (type_list + (type_identifier + (identifier)) + (type_identifier + (identifier)))) + (argument_list + (expression + (primary_expression + (literal + (integer)))) + (expression + (primary_expression + (literal + (string)))))))))) + +================================================================================ +A nested type argument closes two lists with one angle pair [TYPE-GENERICS-APPLY] +================================================================================ + +fn main() = identity>([1]) + +-------------------------------------------------------------------------------- + +(source_file + (statement + (function_declaration + name: (identifier) + body: (expression + (call_expression + callee: (expression + (primary_expression + (identifier))) + type_arguments: (type_arguments + (type_list + (generic_type + name: (identifier) + (type_list + (type_identifier + (identifier)))))) + (argument_list + (expression + (primary_expression + (list_literal + (expression + (primary_expression + (literal + (integer)))))))))))) + +================================================================================ +A spaced comparison is not type application [TYPE-GENERICS-APPLY] +================================================================================ + +fn main() = a < b + +-------------------------------------------------------------------------------- + +(source_file + (statement + (function_declaration + name: (identifier) + body: (expression + (binary_expression + left: (expression + (primary_expression + (identifier))) + right: (expression + (primary_expression + (identifier)))))))) From b012dc860c9b61e1f2ae17a39cce186aa28026cc Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:01:38 +1000 Subject: [PATCH 02/10] fixes --- crates/osprey-ast/src/freevars.rs | 2 +- crates/osprey-ast/src/lib.rs | 9 + crates/osprey-ast/src/mutate.rs | 2 +- crates/osprey-ast/src/resume.rs | 4 +- crates/osprey-ast/src/visit.rs | 2 +- crates/osprey-project/src/rewrite.rs | 6 + crates/osprey-project/src/span.rs | 2 +- crates/osprey-project/src/state.rs | 2 +- crates/osprey-syntax/src/default/expr.rs | 9 +- crates/osprey-syntax/src/ml/cst.rs | 7 + crates/osprey-syntax/src/ml/lower.rs | 4 + crates/osprey-syntax/src/ml/parser.rs | 10 + crates/osprey-types/src/check.rs | 8 +- crates/osprey-types/src/effect_rows.rs | 7 +- crates/osprey-types/src/env.rs | 22 + crates/osprey-types/src/expr.rs | 29 + .../src/generics_variance_assign_tests.rs | 365 + .../src/generics_variance_builtin_tests.rs | 275 + .../src/generics_variance_shape_tests.rs | 179 + .../src/generics_variance_tests.rs | 4 +- crates/osprey-types/src/lib.rs | 6 + crates/osprey-types/src/testutil.rs | 11 + tree-sitter-osprey/grammar.js | 7 +- tree-sitter-osprey/src/grammar.json | 66 +- tree-sitter-osprey/src/node-types.json | 10 + tree-sitter-osprey/src/parser.c | 49332 ++++++++-------- 26 files changed, 26563 insertions(+), 23817 deletions(-) create mode 100644 crates/osprey-types/src/generics_variance_assign_tests.rs create mode 100644 crates/osprey-types/src/generics_variance_builtin_tests.rs create mode 100644 crates/osprey-types/src/generics_variance_shape_tests.rs diff --git a/crates/osprey-ast/src/freevars.rs b/crates/osprey-ast/src/freevars.rs index 499cf33b..1542ccea 100644 --- a/crates/osprey-ast/src/freevars.rs +++ b/crates/osprey-ast/src/freevars.rs @@ -58,7 +58,7 @@ fn walk(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { walk(left, bound, out); walk(right, bound, out); } - Expr::Unary { operand, .. } => walk(operand, bound, out), + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => walk(operand, bound, out), e2 => walk_rest(e2, bound, out), } } diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs index f086f107..3b9777d1 100644 --- a/crates/osprey-ast/src/lib.rs +++ b/crates/osprey-ast/src/lib.rs @@ -765,6 +765,15 @@ pub enum Expr { /// Named arguments. named_arguments: Vec, }, + /// Explicit declaration-binder arguments on a call's callee. + /// Both flavors use this node for [TYPE-GENERICS-APPLY]. Keeping the + /// application on the callee preserves ordinary and curried call nodes. + TypeApply { + /// The named function being instantiated. + function: Box, + /// Written type arguments, in declaration order. + type_args: Vec, + }, /// `a |> b` pipe. Pipe { /// Piped value. diff --git a/crates/osprey-ast/src/mutate.rs b/crates/osprey-ast/src/mutate.rs index be73cec9..04a78a9c 100644 --- a/crates/osprey-ast/src/mutate.rs +++ b/crates/osprey-ast/src/mutate.rs @@ -45,7 +45,7 @@ pub fn children_mut(expression: &mut Expr, visit: &mut impl FnMut(&mut Expr)) { visit(left); visit(right); } - Expr::Unary { operand, .. } + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) diff --git a/crates/osprey-ast/src/resume.rs b/crates/osprey-ast/src/resume.rs index 4c3cb4ee..64b500ea 100644 --- a/crates/osprey-ast/src/resume.rs +++ b/crates/osprey-ast/src/resume.rs @@ -30,7 +30,7 @@ pub fn contains_resume(e: &Expr) -> bool { Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { contains_resume(left) || contains_resume(right) } - Expr::Unary { operand, .. } => contains_resume(operand), + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => contains_resume(operand), Expr::Call { function, arguments, @@ -153,7 +153,7 @@ fn sequential_children(body: &Expr) -> u32 { Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { resumes_on_one_path(left) + resumes_on_one_path(right) } - Expr::Unary { operand, .. } => resumes_on_one_path(operand), + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => resumes_on_one_path(operand), Expr::Call { function, arguments, diff --git a/crates/osprey-ast/src/visit.rs b/crates/osprey-ast/src/visit.rs index 91f69f74..5d715c99 100644 --- a/crates/osprey-ast/src/visit.rs +++ b/crates/osprey-ast/src/visit.rs @@ -99,7 +99,7 @@ fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec pending.push(Node::Expression(right)); pending.push(Node::Expression(left)); } - Expr::Unary { operand, .. } + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) => pending.push(Node::Expression(operand)), diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs index 4bfd0fc1..a9770910 100644 --- a/crates/osprey-project/src/rewrite.rs +++ b/crates/osprey-project/src/rewrite.rs @@ -288,6 +288,12 @@ impl Resolver<'_> { self.rewrite_expr(left, context, locals); self.rewrite_expr(right, context, locals); } + Expr::TypeApply { function, type_args } => { + self.rewrite_expr(function, context, locals); + for argument in type_args { + self.rewrite_type(argument, context, locals); + } + } Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs index bd842b81..d6ddb229 100644 --- a/crates/osprey-project/src/span.rs +++ b/crates/osprey-project/src/span.rs @@ -232,7 +232,7 @@ fn offset_expr(expr: &mut Expr, offset: u32) { offset_expr(left, offset); offset_expr(right, offset); } - Expr::Unary { operand, .. } + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) => offset_expr(operand, offset), diff --git a/crates/osprey-project/src/state.rs b/crates/osprey-project/src/state.rs index d78b38b1..0d11b8a2 100644 --- a/crates/osprey-project/src/state.rs +++ b/crates/osprey-project/src/state.rs @@ -229,7 +229,7 @@ impl<'a> Inspector<'a> { self.expr(left, in_owner_arm, position); self.expr(right, in_owner_arm, position); } - Expr::Unary { operand, .. } | Expr::Await(operand) | Expr::Recv(operand) => { + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::Await(operand) | Expr::Recv(operand) => { self.expr(operand, in_owner_arm, position); } Expr::Spawn(operand) => self.escaping(operand, position), diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index 93d6e1c2..4e0ca55d 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -199,7 +199,14 @@ impl Lowerer<'_> { } fn lower_call(&self, node: Node<'_>) -> Expr { - let callee = self.lower_expr_field(node, "callee"); + let mut callee = self.lower_expr_field(node, "callee"); + if let Some(args) = node.child_by_field_name("type_arguments") { + callee = Expr::TypeApply { + function: Box::new(callee), + type_args: self.named_of_kind(args, "type_list").into_iter() + .flat_map(|list| self.lower_type_list(list)).collect(), + }; + } if let Some(member) = node.child_by_field_name("member") { return Expr::FieldAccess { target: Box::new(callee), diff --git a/crates/osprey-syntax/src/ml/cst.rs b/crates/osprey-syntax/src/ml/cst.rs index 832c6c09..5c57f6c2 100644 --- a/crates/osprey-syntax/src/ml/cst.rs +++ b/crates/osprey-syntax/src/ml/cst.rs @@ -475,6 +475,13 @@ pub(crate) enum MlExpr { /// The argument list (two or more), in order. args: Vec, }, + /// Explicit call-site type arguments [FLAVOR-ML-GENERICS]. + TypeApply { + /// Named callee. + func: Box, + /// Written arguments in binder order. + args: Vec, + }, /// Zero-argument application `func ()`. UnitApp { /// The applied expression. diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index 267cd5c3..a2d470b0 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -1079,6 +1079,10 @@ fn lower_expr(expr: MlExpr) -> Expr { segments: path.segments, }), MlExpr::Paren(inner) => lower_expr(*inner), + MlExpr::TypeApply { func, args } => Expr::TypeApply { + function: Box::new(lower_expr(*func)), + type_args: args.iter().filter_map(type_expr).collect(), + }, // `-literal` folds to the literal so both flavors agree that `-1` is an // `int`, not a fallible `Result` ([ARITH-NEG-LITERAL], [FLAVOR-IR-EQUIV]). MlExpr::Unary { op, operand } if op == "-" => Expr::negated(lower_expr(*operand)), diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index be0811fe..5054780c 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -1174,6 +1174,16 @@ impl Parser<'_> { func = self.inline_record(name, type_args); } } + if record_head(&func).is_some() && self.at_angle_open() && self.glued() { + let args = match self.ty_generic_args(String::new()) { + MlType::App { args, .. } => args, + _ => Vec::new(), + }; + if !self.starts_atom() && !self.at_negative_literal_arg() { + self.error("type arguments require a call argument"); + } + func = MlExpr::TypeApply { func: Box::new(func), args }; + } // `f ()` is a zero-argument application, not application to unit. if matches!(self.peek(), TokKind::LParen) && matches!(self.peek_at(1), TokKind::RParen) { self.advance(); diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 31d4d630..2572fb52 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -599,7 +599,9 @@ impl Checker { let mut typarams = HashMap::new(); for tp in type_params { let v = self.ctx.fresh(); - let _ = typarams.insert(tp.name.clone(), v); + if typarams.insert(tp.name.clone(), v).is_some() { + self.errors.push(TypeError::new(format!("duplicate type parameter `{}`", tp.name))); + } } let params: Vec = parameters .iter() @@ -612,8 +614,10 @@ impl Checker { Some(te) => type_expr_to_type(te, &typarams), None => self.ctx.fresh(), }; + let ordered = type_params.iter().filter_map(|p| typarams.get(&p.name).cloned()).collect(); let _ = self.fn_typarams.insert(name.to_string(), typarams); self.publish_signature(name, parameters, params, ret, env); + env.declare_type_params(name, ordered); } /// Pass two: infer bodies and run top-level statements. @@ -697,9 +701,11 @@ impl Checker { // variables would count as "free in the environment" and nothing would // generalize. let fun_ty = Type::fun(params, ret); + let declared = env.applied(&mut self.ctx, name).map(|(_, _, ps)| ps).unwrap_or_default(); env.remove(name); let scheme = self.generalize_with_obligations(env, &fun_ty); env.insert(name, scheme); + env.declare_type_params(name, declared); } /// Generalize `ty`, carrying every built-in obligation recorded on a diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index 83378940..012b86f5 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -549,7 +549,7 @@ impl Analyzer<'_> { out } Expr::Pipe { left, right } => self.pipe_call(left, right, scope, env), - Expr::Unary { operand, .. } + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::FieldAccess { target: operand, .. } @@ -984,6 +984,7 @@ impl Analyzer<'_> { )] fn value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { match expression { + Expr::TypeApply { function, .. } => self.value(function, scope, env), Expr::Identifier(name) => { if let Some(value) = env.values.get(name) { return Some(value.clone()); @@ -1553,6 +1554,7 @@ fn receiver_first(receiver: &Expr, arguments: &[Expr]) -> Vec { fn expression_name(expression: &Expr) -> Option<&str> { match expression { + Expr::TypeApply { function, .. } => expression_name(function), Expr::Identifier(name) => Some(name), Expr::Path(path) => path.last(), _ => None, @@ -1571,6 +1573,7 @@ fn expression_name(expression: &Expr) -> Option<&str> { /// contributed nothing at all, not even a provenance failure. fn statically_named_callee(expression: &Expr, env: &CallableEnv, index: &Index) -> bool { match expression { + Expr::TypeApply { function, .. } => statically_named_callee(function, env, index), Expr::Identifier(name) => { !env.shadowed.contains(name) && (crate::builtins::builtin_signature(name).is_some() @@ -2577,7 +2580,7 @@ fn walk_children<'a>(expression: &'a Expr, mut visit: impl FnMut(&'a Expr)) { visit(left); visit(right); } - Expr::Unary { operand, .. } + Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::FieldAccess { target: operand, .. } diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index 2987250e..cb4345a6 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -12,6 +12,8 @@ use std::collections::{BTreeSet, HashMap, HashSet}; #[derive(Debug, Clone, Default)] pub struct TypeEnv { vars: HashMap, + /// Ordered declaration binders, cleared whenever a value shadows a name. + type_params: HashMap>, /// Names declared `mut` — the only bindings handler-arm assignment may target. mutables: HashSet, } @@ -29,12 +31,14 @@ impl TypeEnv { let name = name.into(); // A fresh binding shadows any outer `mut` of the same name. let _ = self.mutables.remove(&name); + let _ = self.type_params.remove(&name); let _ = self.vars.insert(name, scheme); } /// Bind a `mut` declaration — the one binding form handler arms may assign. pub fn insert_mutable(&mut self, name: impl Into, scheme: Scheme) { let name = name.into(); + let _ = self.type_params.remove(&name); let _ = self.vars.insert(name.clone(), scheme); let _ = self.mutables.insert(name); } @@ -51,6 +55,24 @@ impl TypeEnv { pub fn remove(&mut self, name: &str) { let _ = self.vars.remove(name); + let _ = self.type_params.remove(name); + } + + /// Attach declaration-site binders to this exact lexical binding. + pub(crate) fn declare_type_params(&mut self, name: &str, params: Vec) { + let _ = self.type_params.insert(name.to_owned(), params); + } + + /// Instantiate the signature and its declared binders with one substitution. + pub(crate) fn applied(&self, ctx: &mut InferCtx, name: &str) + -> Option<(Type, Vec<(String, Type)>, Vec)> { + let scheme = self.get(name)?; + let map = scheme.vars.iter().map(|v| (*v, ctx.fresh())).collect(); + let params = self.type_params.get(name).into_iter().flatten() + .map(|ty| subst_vars(&ctx.apply(ty), &map)).collect(); + let obligations = scheme.obligations.iter() + .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))).collect(); + Some((subst_vars(&scheme.ty, &map), obligations, params)) } /// A fresh child scope (a clone — bindings added to the child don't leak). diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index 631dfd2b..63a26634 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -86,6 +86,7 @@ impl Checker { self.infer_negation(&t) } } + Expr::TypeApply { function, type_args } => self.infer_type_application(function, type_args, env).1, Expr::Call { function, arguments, @@ -549,6 +550,7 @@ impl Checker { fn infer_callee(&mut self, function: &Expr, env: &TypeEnv) -> (Option, Type) { match function { + Expr::TypeApply { function, type_args } => self.infer_type_application(function, type_args, env), Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident(name, env)), Expr::Path(path) => { let name = path.to_string(); @@ -559,6 +561,33 @@ impl Checker { } } + /// Pin declared binders in this call's fresh instantiation [TYPE-GENERICS-APPLY]. + fn infer_type_application(&mut self, function: &Expr, type_args: &[osprey_ast::TypeExpr], env: &TypeEnv) + -> (Option, Type) { + let name = match function { + Expr::Identifier(name) => name.clone(), + Expr::Path(path) => path.to_string(), + _ => { + self.errors.push(TypeError::new("type arguments require a named function")); + return (None, self.infer_expr(function, env)); + } + }; + let Some((ty, obligations, params)) = env.applied(&mut self.ctx, &name) else { + return (Some(name.clone()), self.lookup_ident(&name, env)); + }; + self.builtin_uses.extend(obligations); + if params.len() != type_args.len() { + self.errors.push(TypeError::new(format!("function `{name}` takes {} type argument(s), got {}", params.len(), type_args.len()))); + } else { + let binder = self.current_fn_typarams.clone(); + for (param, arg) in params.iter().zip(type_args) { + let written = crate::convert::type_expr_to_type(arg, &binder); + self.push_unify(param, &written); + } + } + (Some(name), ty) + } + fn infer_method_call( &mut self, target: &Expr, diff --git a/crates/osprey-types/src/generics_variance_assign_tests.rs b/crates/osprey-types/src/generics_variance_assign_tests.rs new file mode 100644 index 00000000..4aaa029d --- /dev/null +++ b/crates/osprey-types/src/generics_variance_assign_tests.rs @@ -0,0 +1,365 @@ +//! Spec-driven assertions for the **directional** half of +//! [TYPE-VARIANCE-ASSIGN] (docs/specs/0004-TypeSystem.md). +//! +//! "At *assignment sites* (call arguments, annotated bindings, return +//! positions), a variance-declared constructor's arguments are matched +//! directionally: covariant (`out`) arguments recurse expected-accepts-actual, +//! contravariant (`in`) arguments recurse with the roles flipped, invariant +//! arguments unify exactly." +//! +//! `generics_variance_tests.rs` states where a marker may be WRITTEN; this +//! module states what writing it BUYS. The distinction matters because the two +//! shipped fixtures (`variance_covariant_result_payload.ospo` and +//! `variance_invariant_arg_mismatch.ospo`) assert the same rejection under +//! `out T` and under an unannotated parameter — so nothing in the tree today +//! separates a covariant container from an invariant one, and a checker that +//! ignored every marker at assignment sites would pass both. +//! +//! The relation being recursed is the one-way promotion `T -> Result` +//! that the direct value site already models (`the_direct_site_promotion_is_the +//! _relation_being_recursed` below is its control). Every claim here is made at +//! ALL THREE sites the spec names, because a relation implemented at one site +//! is not the relation the spec describes. + +use crate::testutil::{accepts, rejects}; +use osprey_syntax::Flavor; + +/// The three assignment sites [TYPE-VARIANCE-ASSIGN] names, for a value of the +/// type `actual` produces flowing into a slot annotated `expected`. +pub(crate) fn sites(decls: &str, expected: &str, actual: &str) -> [String; 3] { + [ + format!("{decls}fn takes(v: {expected}) = 0\nprint(\"${{takes({actual})}}\")\n"), + format!("{decls}let held: {expected} = {actual}\nprint(\"bound\")\n"), + format!("{decls}fn gives() -> {expected} = {actual}\nprint(\"declared\")\n"), + ] +} + +/// Assert the value flows into the slot at every assignment site. +pub(crate) fn flows(decls: &str, expected: &str, actual: &str) { + for src in sites(decls, expected, actual) { + accepts(Flavor::Default, &src); + } +} + +/// Assert the value is refused at every assignment site. +pub(crate) fn blocked(decls: &str, expected: &str, actual: &str) { + for src in sites(decls, expected, actual) { + rejects(Flavor::Default, &src); + } +} + +/// A covariant container, plus producers at both instantiations. +const FEED: &str = "type Feed = Feed { supply: T } | Dry\n\ + fn feedInt() -> Feed = Feed { supply: 1 }\n\ + fn feedRes() -> Feed> = Feed { supply: 20 * 5 }\n\ + fn feedText() -> Feed = Feed { supply: \"s\" }\n"; + +/// A contravariant container, same shape. +const GATE: &str = "type Gate = Gate { admit: (T) -> bool } | Open\n\ + fn gateInt() -> Gate = Gate { admit: |x| => true }\n\ + fn gateRes() -> Gate> = Gate { admit: |x| => true }\n\ + fn gateText() -> Gate = Gate { admit: |x| => true }\n"; + +/// An invariant container. +const CELL: &str = "type Cell = Cell { slot: T }\n\ + fn cellInt() -> Cell = Cell { slot: 1 }\n\ + fn cellRes() -> Cell> = Cell { slot: 20 * 5 }\n"; + +/// The three containers nested one level inside each other. +const NESTED: &str = "type Feed = Feed { supply: T } | Dry\n\ + type Gate = Gate { admit: (T) -> bool } | Open\n\ + type Cell = Cell { slot: T }\n\ + fn feedFeedInt() -> Feed> = Feed { supply: Feed { supply: 1 } }\n\ + fn feedGateInt() -> Feed> = Feed { supply: Gate { admit: |x| => true } }\n\ + fn feedGateRes() -> Feed>> = \ + Feed { supply: Gate { admit: |x| => true } }\n\ + fn feedCellInt() -> Feed> = Feed { supply: Cell { slot: 1 } }\n\ + fn gateFeedRes() -> Gate>> = Gate { admit: |x| => true }\n\ + fn gateGateInt() -> Gate> = Gate { admit: |x| => true }\n"; + +/// A covariant container over FUNCTION payloads, where the structural rule +/// (contravariant parameters, covariant returns) is the thing recursed into. +const FNPAYLOAD: &str = "type Feed = Feed { supply: T } | Dry\n\ + fn feedTakesInt() -> Feed<(int) -> bool> = Feed { supply: |x| => true }\n\ + fn feedTakesRes() -> Feed<(Result) -> bool> = \ + Feed { supply: |x| => true }\n\ + fn feedGivesInt() -> Feed<(int) -> int> = Feed { supply: |x| => 1 }\n\ + fn feedGivesRes() -> Feed<(int) -> Result> = Feed { supply: |x| => x * 2 }\n"; + +// --------------------------------------------------------------------------- +// The control: the relation exists at depth 0 +// --------------------------------------------------------------------------- + +/// The one-way promotion `T -> Result` holds at a direct value site. Every +/// rejection below that should have been an acceptance is therefore a failure to +/// RECURSE the relation, not a missing relation. +#[test] +fn the_direct_site_promotion_is_the_relation_being_recursed() { + flows("", "Result", "5"); +} + +/// Its inverse never holds, at depth 0 or anywhere else. +#[test] +fn the_inverse_promotion_never_holds_at_the_direct_site() { + blocked("fn half() -> Result = 10 / 2\n", "int", "half()"); +} + +// --------------------------------------------------------------------------- +// Covariance: `out` arguments recurse expected-accepts-actual +// --------------------------------------------------------------------------- + +/// A `Feed` flows into a `Feed>` slot: the covariant +/// argument recurses the promotion. This is the ENTIRE payoff of writing `out`, +/// and nothing in the tree asserted it before. +#[test] +fn covariance_carries_the_promotion_into_the_argument() { + flows(FEED, "Feed>", "feedInt()"); +} + +/// The unwrapping direction stays refused — "no `Result`-to-`T` coercion +/// at any depth". +#[test] +fn covariance_never_unwraps_a_result_payload() { + blocked(FEED, "Feed", "feedRes()"); +} + +/// The identical instantiation is the baseline both directions are measured +/// against. +#[test] +fn covariance_accepts_the_identical_instantiation() { + flows(FEED, "Feed", "feedInt()"); +} + +/// Covariance is not "anything goes": an unrelated payload is still refused. +#[test] +fn covariance_rejects_an_unrelated_payload() { + blocked(FEED, "Feed", "feedText()"); + blocked(FEED, "Feed", "feedInt()"); +} + +// --------------------------------------------------------------------------- +// Contravariance: `in` arguments recurse with the roles flipped +// --------------------------------------------------------------------------- + +/// A `Gate>` flows into a `Gate` slot — the flipped +/// recursion, and the entire payoff of writing `in`. +#[test] +fn contravariance_carries_the_promotion_with_the_roles_flipped() { + flows(GATE, "Gate", "gateRes()"); +} + +/// The unflipped direction is refused: a gate admitting only `int` cannot stand +/// where one admitting a `Result` is expected. +#[test] +fn contravariance_rejects_the_covariant_direction() { + blocked(GATE, "Gate>", "gateInt()"); +} + +/// The baseline. +#[test] +fn contravariance_accepts_the_identical_instantiation() { + flows(GATE, "Gate", "gateInt()"); +} + +/// And it is not "anything goes" either. +#[test] +fn contravariance_rejects_an_unrelated_payload() { + blocked(GATE, "Gate", "gateText()"); +} + +// --------------------------------------------------------------------------- +// Invariance: arguments unify exactly, in BOTH directions +// --------------------------------------------------------------------------- + +/// An unannotated parameter refuses the promotion the covariant one carries. +/// This test and `covariance_carries_the_promotion_into_the_argument` are the +/// pair that separates a covariant container from an invariant one; the shipped +/// fixtures assert only the half both share. +#[test] +fn invariance_refuses_the_promotion_in_both_directions() { + blocked(CELL, "Cell>", "cellInt()"); + blocked(CELL, "Cell", "cellRes()"); +} + +/// The baseline. +#[test] +fn invariance_accepts_the_identical_instantiation() { + flows(CELL, "Cell", "cellInt()"); +} + +// --------------------------------------------------------------------------- +// Composition: "a nested constructor's argument composes the position" +// --------------------------------------------------------------------------- + +/// `out` inside `out` stays covariant, so the promotion reaches two levels down. +#[test] +fn covariance_composes_with_covariance() { + flows(NESTED, "Feed>>", "feedFeedInt()"); +} + +/// `in` inside `out` flips once: the inner argument recurses backwards. +#[test] +fn contravariance_inside_covariance_flips_once() { + flows(NESTED, "Feed>", "feedGateRes()"); +} + +/// …and the unflipped direction stays refused at that depth. +#[test] +fn contravariance_inside_covariance_rejects_the_unflipped_direction() { + blocked(NESTED, "Feed>>", "feedGateInt()"); +} + +/// `out` inside `in` flips the outer relation, so the value travels the other +/// way. +#[test] +fn covariance_inside_contravariance_flips_once() { + flows(NESTED, "Gate>", "gateFeedRes()"); +} + +/// Two flips compose back to covariance. +#[test] +fn contravariance_inside_contravariance_composes_back_to_covariance() { + flows(NESTED, "Gate>>", "gateGateInt()"); +} + +/// An invariant argument stops the recursion whatever encloses it. +#[test] +fn an_invariant_argument_stops_the_recursion() { + blocked(NESTED, "Feed>>", "feedCellInt()"); +} + +// --------------------------------------------------------------------------- +// Function payloads: contravariant parameters, covariant returns +// --------------------------------------------------------------------------- + +/// "Function types are structurally contravariant in parameters": a function +/// accepting a `Result` stands where one accepting an `int` is expected. +#[test] +fn a_function_payload_is_contravariant_in_its_parameter() { + flows(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesRes()"); +} + +/// The opposite direction is refused. +#[test] +fn a_function_payload_rejects_a_widened_parameter() { + blocked(FNPAYLOAD, "Feed<(Result) -> bool>", "feedTakesInt()"); +} + +/// "…and covariant in returns": a function returning `int` stands where one +/// returning `Result` is expected. +#[test] +fn a_function_payload_is_covariant_in_its_return() { + flows(FNPAYLOAD, "Feed<(int) -> Result>", "feedGivesInt()"); +} + +/// The spec's own counterexample: "a `Feed<(int) -> Result>` does +/// not match a `Feed<(int) -> int>` slot". +#[test] +fn the_spec_counterexample_stays_refused() { + blocked(FNPAYLOAD, "Feed<(int) -> int>", "feedGivesRes()"); +} + +// --------------------------------------------------------------------------- +// The same relation through the ML surface ([FLAVOR-BOUNDARY]) +// --------------------------------------------------------------------------- + +/// The ML twin of the covariant payoff. +#[test] +fn ml_covariance_carries_the_promotion_into_the_argument() { + accepts( + Flavor::Ml, + "type Feed out T =\n supply : T\n\ + feedInt : Unit -> Feed\n\ + feedInt () = Feed(supply = 1)\n\ + takes : Feed> -> int\n\ + takes v = 0\n\ + held = takes (feedInt ())\n\ + print \"${held}\"\n", + ); +} + +/// The ML twin of the contravariant payoff. +#[test] +fn ml_contravariance_carries_the_promotion_with_the_roles_flipped() { + accepts( + Flavor::Ml, + "type Gate in T =\n admit : T -> bool\n\ + gateRes : Unit -> Gate>\n\ + gateRes () = Gate(admit = \\x => true)\n\ + takes : Gate -> int\n\ + takes v = 0\n\ + held = takes (gateRes ())\n\ + print \"${held}\"\n", + ); +} + +/// The ML twin of the invariant refusal. +#[test] +fn ml_invariance_refuses_the_promotion() { + rejects( + Flavor::Ml, + "type Cell T =\n slot : T\n\ + cellInt : Unit -> Cell\n\ + cellInt () = Cell(slot = 1)\n\ + takes : Cell> -> int\n\ + takes v = 0\n\ + held = takes (cellInt ())\n\ + print \"${held}\"\n", + ); +} + +// --------------------------------------------------------------------------- +// The collapse detector +// --------------------------------------------------------------------------- + +/// True when the checker accepts the program outright. +fn accepted(src: &str) -> bool { + crate::testutil::typecheck(Flavor::Default, src).is_empty() +} + +/// [TYPE-VARIANCE-ASSIGN] opens by saying variance DIRECTS assignability, then +/// closes by saying the recursion "bottoms out in exact unification". Read +/// strictly, the second sentence empties the first: if every leaf must match +/// exactly, `out T`, `in T` and an unannotated parameter accept and refuse +/// exactly the same programs, and the marker's only teeth are +/// [TYPE-VARIANCE-POSITIONS]. +/// +/// This test does not take a side. It asserts only that the two readings are +/// distinguishable in the tree — that SOMETHING about assignment changes when +/// the marker changes. If it fails, the first sentence of [TYPE-VARIANCE-ASSIGN] +/// describes nothing the compiler does and the spec is the stale source; the +/// two shipped fixtures cannot see this, because both assert the one direction +/// all three markers agree on. +#[test] +fn the_marker_must_change_at_least_one_assignment_outcome() { + let covariant = accepted(&sites(FEED, "Feed>", "feedInt()")[0]); + let contravariant = accepted(&sites(GATE, "Gate", "gateRes()")[0]); + let invariant_forward = accepted(&sites(CELL, "Cell>", "cellInt()")[0]); + let invariant_flipped = accepted(&sites(CELL, "Cell", "cellRes()")[0]); + + assert!( + covariant != invariant_forward || contravariant != invariant_flipped, + "variance is inert at assignment sites: out={covariant}, in={contravariant}, \ + invariant={invariant_forward}/{invariant_flipped} — all three markers accept and \ + refuse the same programs, so [TYPE-VARIANCE-ASSIGN]'s directional rule has no \ + observable content and only [TYPE-VARIANCE-POSITIONS] is load-bearing" + ); +} + +/// The other half of the same question, asked of the built-in table: `List` is +/// declared `out` and `Channel` invariant, so at least one program must +/// separate them. +#[test] +fn a_builtin_marker_must_change_at_least_one_assignment_outcome() { + const BUILTINS: &str = "fn listInt() -> List = [1]\n\ + fn chanInt() -> Channel = Channel(2)\n"; + let covariant = accepted(&sites(BUILTINS, "List>", "listInt()")[0]); + let invariant = accepted(&sites(BUILTINS, "Channel>", "chanInt()")[0]); + + assert!( + covariant != invariant, + "`List` and `Channel` are indistinguishable at assignment sites \ + (both {covariant}), so the built-in variance table in [TYPE-VARIANCE-ASSIGN] \ + records nothing the compiler consults" + ); +} diff --git a/crates/osprey-types/src/generics_variance_builtin_tests.rs b/crates/osprey-types/src/generics_variance_builtin_tests.rs new file mode 100644 index 00000000..3b71b62a --- /dev/null +++ b/crates/osprey-types/src/generics_variance_builtin_tests.rs @@ -0,0 +1,275 @@ +//! The **built-in variance table** of [TYPE-VARIANCE-ASSIGN], asserted through +//! the assignment sites rather than read off the declaration +//! (docs/specs/0004-TypeSystem.md). +//! +//! "Built-in constructors' declared variance: `Result`, +//! `List`, `Fiber`, `Map` (keys invariant); `Channel` +//! and `Ptr` are invariant. Function types are structurally contravariant in +//! parameters and covariant in returns." +//! +//! Each entry in that sentence is a claim about what flows where, so each gets +//! its accepting direction, its refusing direction and its identical-instance +//! baseline — the three together are what distinguish a covariant entry from an +//! invariant one. The relation recursed is the promotion `T -> Result`, +//! whose depth-0 control lives in `generics_variance_assign_tests.rs`. + +use crate::generics_variance_assign_tests::{blocked, flows}; + +/// Producers for every built-in shape under test, at both instantiations. +const BUILTINS: &str = "fn listInt() -> List = [1]\n\ + fn listRes() -> List> = [20 * 5]\n\ + fn mapInt() -> Map = { \"a\": 1 }\n\ + fn mapRes() -> Map> = { \"a\": 20 * 5 }\n\ + fn mapIntKeys() -> Map = { 1: 2 }\n\ + fn resInt() -> Result = 20 * 5\n\ + fn one() = 1\n\ + fn fiberInt() -> Fiber = spawn one()\n\ + fn chanInt() -> Channel = Channel(2)\n\ + fn chanRes() -> Channel> = Channel(2)\n\ + fn takesInt(v: int) = true\n\ + fn takesRes(v: Result) = true\n\ + fn givesInt(v: int) = 1\n\ + fn givesRes(v: int) = v * 2\n"; + +/// Built-ins nested inside each other and inside a declared covariant +/// container, so composition is exercised through the table too. +const NESTED_BUILTINS: &str = "type Feed = Feed { supply: T } | Dry\n\ + type Gate = Gate { admit: (T) -> bool } | Open\n\ + fn listListInt() -> List> = [[1]]\n\ + fn mapListInt() -> Map> = { \"a\": [1] }\n\ + fn resListInt() -> Result, MathError> = [1]\n\ + fn feedListInt() -> Feed> = Feed { supply: [1] }\n\ + fn gateListRes() -> Gate>> = Gate { admit: |x| => true }\n\ + fn gateListInt() -> Gate> = Gate { admit: |x| => true }\n"; + +// --------------------------------------------------------------------------- +// List +// --------------------------------------------------------------------------- + +/// A `List` flows into a `List>` slot. +#[test] +fn list_carries_the_promotion_into_its_element() { + flows(BUILTINS, "List>", "listInt()"); +} + +/// The unwrapping direction is refused. +#[test] +fn list_never_unwraps_its_element() { + blocked(BUILTINS, "List", "listRes()"); +} + +/// The baseline. +#[test] +fn list_accepts_the_identical_element() { + flows(BUILTINS, "List", "listInt()"); +} + +/// Covariance is not looseness: an unrelated element is refused. +#[test] +fn list_rejects_an_unrelated_element() { + blocked(BUILTINS, "List", "listInt()"); +} + +// --------------------------------------------------------------------------- +// Result +// --------------------------------------------------------------------------- + +/// The VALUE channel is covariant. +#[test] +fn result_carries_the_promotion_into_its_value() { + flows( + BUILTINS, + "Result, MathError>", + "resInt()", + ); +} + +/// The ERROR channel is covariant too — the second half of the table entry, +/// which nothing in the tree exercised. +#[test] +fn result_carries_the_promotion_into_its_error() { + flows( + BUILTINS, + "Result>", + "resInt()", + ); +} + +/// Neither channel unwraps. +#[test] +fn result_never_unwraps_either_channel() { + blocked(BUILTINS, "Result", "listRes()"); +} + +// --------------------------------------------------------------------------- +// Fiber +// --------------------------------------------------------------------------- + +/// A `Fiber` flows into a `Fiber>` slot. +#[test] +fn fiber_carries_the_promotion_into_its_answer() { + flows(BUILTINS, "Fiber>", "fiberInt()"); +} + +/// The baseline. +#[test] +fn fiber_accepts_the_identical_answer() { + flows(BUILTINS, "Fiber", "fiberInt()"); +} + +/// An unrelated answer is refused. +#[test] +fn fiber_rejects_an_unrelated_answer() { + blocked(BUILTINS, "Fiber", "fiberInt()"); +} + +// --------------------------------------------------------------------------- +// Map — the value is covariant, the key is NOT +// --------------------------------------------------------------------------- + +/// The value channel carries the promotion. +#[test] +fn map_carries_the_promotion_into_its_value() { + flows( + BUILTINS, + "Map>", + "mapInt()", + ); +} + +/// The value channel does not unwrap. +#[test] +fn map_never_unwraps_its_value() { + blocked(BUILTINS, "Map", "mapRes()"); +} + +/// "(keys invariant)" — the key channel refuses the promotion the value channel +/// carries. This pair is the whole content of that parenthesis. +#[test] +fn map_keys_refuse_the_promotion_in_both_directions() { + blocked( + BUILTINS, + "Map, int>", + "mapIntKeys()", + ); +} + +/// The baseline. +#[test] +fn map_accepts_the_identical_instantiation() { + flows(BUILTINS, "Map", "mapInt()"); +} + +// --------------------------------------------------------------------------- +// Channel — invariant in both directions +// --------------------------------------------------------------------------- + +/// A channel is written as well as read, so neither direction is safe. +#[test] +fn channel_refuses_the_promotion_in_both_directions() { + blocked(BUILTINS, "Channel>", "chanInt()"); + blocked(BUILTINS, "Channel", "chanRes()"); +} + +/// The baseline. +#[test] +fn channel_accepts_the_identical_element() { + flows(BUILTINS, "Channel", "chanInt()"); +} + +// --------------------------------------------------------------------------- +// Function types — contravariant parameters, covariant returns +// --------------------------------------------------------------------------- + +/// A function accepting a `Result` stands where one accepting an `int` is +/// expected: the parameter position is contravariant. +#[test] +fn a_function_slot_is_contravariant_in_its_parameter() { + flows(BUILTINS, "(int) -> bool", "takesRes"); +} + +/// The widened direction is refused. +#[test] +fn a_function_slot_rejects_a_widened_parameter() { + blocked(BUILTINS, "(Result) -> bool", "takesInt"); +} + +/// A function returning `int` stands where one returning `Result` is +/// expected: the return position is covariant. +#[test] +fn a_function_slot_is_covariant_in_its_return() { + flows(BUILTINS, "(int) -> Result", "givesInt"); +} + +/// The unwrapping direction is refused. +#[test] +fn a_function_slot_never_unwraps_its_return() { + blocked(BUILTINS, "(int) -> int", "givesRes"); +} + +/// The baseline. +#[test] +fn a_function_slot_accepts_the_identical_shape() { + flows(BUILTINS, "(int) -> bool", "takesInt"); +} + +// --------------------------------------------------------------------------- +// Composition through the table +// --------------------------------------------------------------------------- + +/// `List` inside `List` stays covariant. +#[test] +fn list_composes_with_list() { + flows( + NESTED_BUILTINS, + "List>>", + "listListInt()", + ); +} + +/// A covariant built-in inside a covariant built-in's value channel. +#[test] +fn map_composes_with_list_in_its_value() { + flows( + NESTED_BUILTINS, + "Map>>", + "mapListInt()", + ); +} + +/// A covariant built-in inside `Result`'s value channel. +#[test] +fn result_composes_with_list_in_its_value() { + flows( + NESTED_BUILTINS, + "Result>, MathError>", + "resListInt()", + ); +} + +/// A built-in inside a DECLARED covariant container: the two tables are one +/// relation, not two. +#[test] +fn a_declared_covariant_container_composes_with_a_builtin() { + flows( + NESTED_BUILTINS, + "Feed>>", + "feedListInt()", + ); +} + +/// …and inside a declared CONTRAVARIANT container the composition flips. +#[test] +fn a_declared_contravariant_container_flips_a_builtin() { + flows(NESTED_BUILTINS, "Gate>", "gateListRes()"); +} + +/// The unflipped direction stays refused at that depth. +#[test] +fn a_declared_contravariant_container_rejects_the_unflipped_builtin() { + blocked( + NESTED_BUILTINS, + "Gate>>", + "gateListInt()", + ); +} diff --git a/crates/osprey-types/src/generics_variance_shape_tests.rs b/crates/osprey-types/src/generics_variance_shape_tests.rs new file mode 100644 index 00000000..f027b757 --- /dev/null +++ b/crates/osprey-types/src/generics_variance_shape_tests.rs @@ -0,0 +1,179 @@ +//! Variance position checking over the SHAPES a declaration can take +//! ([TYPE-VARIANCE-POSITIONS], docs/specs/0004-TypeSystem.md): positions reached +//! through the built-in constructors, a parameter used in both directions at +//! once, several parameters with mixed markers, and union variants — named and +//! positional. +//! +//! The single-field core matrix is `generics_variance_tests.rs`, whose `decl` +//! and `position_message` helpers this module reuses. + +use crate::generics_variance_tests::{decl, position_message}; +use crate::testutil::{accepts, check, rejected_somehow, rejects_with}; +use osprey_syntax::Flavor; + +/// A function type inside a covariant built-in still flips its parameter. +#[test] +fn out_in_a_function_parameter_inside_a_list_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "checks", "List<(T) -> int>"), + &position_message("T", "out", "input", "checks", "Holder"), + ); +} + +/// The `Result` ERROR channel is an output position too. +#[test] +fn out_is_legal_in_the_result_error_channel() { + accepts(Flavor::Default, &decl("", "failure", "Result")); +} + +/// …so a contravariant parameter is rejected there. +#[test] +fn in_in_the_result_error_channel_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "failure", "Result"), + &position_message("T", "in", "output", "failure", "Holder"), + ); +} + +/// `Fiber` is an output position, so `in T` cannot sit there. +#[test] +fn in_inside_a_fiber_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "worker", "Fiber"), + &position_message("T", "in", "output", "worker", "Holder"), + ); +} + +/// `Map`: a contravariant parameter is rejected in the VALUE channel. +#[test] +fn in_in_a_map_value_is_rejected() { + rejects_with( + Flavor::Default, + &decl("", "byName", "Map"), + &position_message("T", "in", "output", "byName", "Holder"), + ); +} + +/// …and in the invariant KEY channel, both markers are refused. +#[test] +fn map_keys_refuse_both_markers() { + rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); + rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-POSITIONS] — a parameter used in BOTH positions +// --------------------------------------------------------------------------- + +/// A record that both holds and consumes its parameter demands both +/// directions, so only an invariant parameter fits. +fn both_positions(params: &str) -> String { + format!("type Holder{params} = {{{{ held: T, consume: (T) -> int }}}}\nprint(\"declared\")") +} + +/// The invariant spelling is accepted. +#[test] +fn a_parameter_used_in_both_positions_may_be_invariant() { + accepts(Flavor::Default, &both_positions("")); +} + +/// The covariant spelling is rejected on the input half. +#[test] +fn a_parameter_used_in_both_positions_may_not_be_covariant() { + rejects_with( + Flavor::Default, + &both_positions(""), + &position_message("T", "out", "input", "consume", "Holder"), + ); +} + +/// The contravariant spelling is rejected on the output half. +#[test] +fn a_parameter_used_in_both_positions_may_not_be_contravariant() { + rejects_with( + Flavor::Default, + &both_positions(""), + &position_message("T", "in", "output", "held", "Holder"), + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-DECL] — several parameters, each checked on its own +// --------------------------------------------------------------------------- + +/// Mixed markers on one declaration are checked independently. +#[test] +fn mixed_markers_are_checked_per_parameter() { + accepts( + Flavor::Default, + "type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")", + ); +} + +/// Swapping the two markers puts each parameter in the wrong position. +#[test] +fn swapped_markers_are_rejected_per_parameter() { + let errs = check( + "type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")", + ); + assert!( + errs.iter() + .any(|e| e.message.contains(&position_message("A", "in", "output", "give", "Two"))), + "expected the `A` violation: {errs:?}" + ); + assert!( + errs.iter() + .any(|e| e.message.contains(&position_message("B", "out", "input", "take", "Two"))), + "expected the `B` violation: {errs:?}" + ); +} + +// --------------------------------------------------------------------------- +// [TYPE-VARIANCE-POSITIONS] — union variants, including positional payloads +// --------------------------------------------------------------------------- + +/// A union variant's payload is an output position. +#[test] +fn out_is_legal_in_a_union_variant_payload() { + accepts( + Flavor::Default, + "type Maybe = Some { value: T } | None\nprint(\"declared\")", + ); +} + +/// …so a contravariant parameter is rejected there. +#[test] +fn in_in_a_union_variant_payload_is_rejected() { + rejects_with( + Flavor::Default, + "type Maybe = Some { value: T } | None\nprint(\"declared\")", + &position_message("T", "in", "output", "value", "Maybe"), + ); +} + +/// A POSITIONAL payload is the same output position under a different spelling +/// ([TYPE-UNION-POSITIONAL]). +#[test] +fn a_positional_variant_payload_is_an_output_position() { + accepts( + Flavor::Default, + "type Maybe = Some(T) | None\nprint(\"declared\")", + ); + rejected_somehow( + Flavor::Default, + "type Maybe = Some(T) | None\nprint(\"declared\")", + ); +} + +/// Every variant is walked, not just the first. +#[test] +fn a_violation_in_a_later_variant_is_still_found() { + rejects_with( + Flavor::Default, + "type Split = First { ok: T } | Second { consume: (T) -> int } | Empty\nprint(\"declared\")", + &position_message("T", "out", "input", "consume", "Split"), + ); +} diff --git a/crates/osprey-types/src/generics_variance_tests.rs b/crates/osprey-types/src/generics_variance_tests.rs index 1f098e39..cf00aa4a 100644 --- a/crates/osprey-types/src/generics_variance_tests.rs +++ b/crates/osprey-types/src/generics_variance_tests.rs @@ -15,12 +15,12 @@ use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position use osprey_syntax::Flavor; /// The position diagnostic for a type declaration's FIELD. -fn position_message(param: &str, marker: &str, position: &str, field: &str, owner: &str) -> String { +pub(crate) fn position_message(param: &str, marker: &str, position: &str, field: &str, owner: &str) -> String { variance_position_message(param, marker, position, "field", field, owner) } /// A one-field record declaration, the smallest carrier of a position. -fn decl(params: &str, field: &str, ty: &str) -> String { +pub(crate) fn decl(params: &str, field: &str, ty: &str) -> String { format!("type Holder{params} = {{ {field}: {ty} }}\nprint(\"declared\")") } diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index 8454821a..b3c5b955 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -38,6 +38,12 @@ mod generics_apply_tests; #[cfg(test)] mod generics_decl_tests; #[cfg(test)] +mod generics_variance_assign_tests; +#[cfg(test)] +mod generics_variance_builtin_tests; +#[cfg(test)] +mod generics_variance_shape_tests; +#[cfg(test)] mod generics_variance_tests; mod info; mod init_order; diff --git a/crates/osprey-types/src/testutil.rs b/crates/osprey-types/src/testutil.rs index 799095e0..a906e31b 100644 --- a/crates/osprey-types/src/testutil.rs +++ b/crates/osprey-types/src/testutil.rs @@ -59,6 +59,17 @@ pub(crate) fn rejects_with(flavor: Flavor, src: &str, needle: &str) { ); } +/// Assert the CHECKER rejects `src`, whatever the wording. Used where the claim +/// is that a relation does NOT hold, and pinning one sentence would over-specify +/// which of several true diagnostics must be the one reported. +pub(crate) fn rejects(flavor: Flavor, src: &str) { + let errs = typecheck(flavor, src); + assert!( + !errs.is_empty(), + "{flavor}: expected a type error, got none\n{src}" + ); +} + /// Assert `src` is rejected SOMEHOW — by the parser or by the checker. Used /// where the spec forbids a form without fixing which layer must catch it. pub(crate) fn rejected_somehow(flavor: Flavor, src: &str) { diff --git a/tree-sitter-osprey/grammar.js b/tree-sitter-osprey/grammar.js index c885df7b..f2db83fc 100644 --- a/tree-sitter-osprey/grammar.js +++ b/tree-sitter-osprey/grammar.js @@ -523,6 +523,10 @@ module.exports = grammar({ // arm's `(a, b)` tuple pattern instead. Implements [PATTERN-TUPLE] // coexistence with postfix calls. seq($._call_open_gap, '(', optional($.argument_list), ')'), + // [TYPE-GENERICS-APPLY]: both delimiters abut the call. Alias the + // immediate opening form to the shared construction-site CST. + seq(field('type_arguments', alias($._call_type_arguments, $.type_arguments)), + token.immediate('('), optional($.argument_list), ')'), // The index `[` must IMMEDIATELY follow its target — a stricter rule // than the call's same-line one, and deliberately so. List-pattern // arms are written on ONE line in real source: @@ -582,7 +586,8 @@ module.exports = grammar({ type_constructor: ($) => prec.dynamic(1, seq(field('name', choice($.qualified_path, $.identifier)), optional($.type_arguments), '{', $.field_assignments, '}')), - type_arguments: ($) => seq('<', $.type_list, '>'), + type_arguments: ($) => seq(token.immediate('<'), $.type_list, '>'), + _call_type_arguments: ($) => seq(token.immediate('<'), $.type_list, '>'), update_expression: ($) => prec.dynamic(0, seq(field('record', $.identifier), '{', $.field_assignments, '}')), diff --git a/tree-sitter-osprey/src/grammar.json b/tree-sitter-osprey/src/grammar.json index a1e9d0e0..6283c79c 100644 --- a/tree-sitter-osprey/src/grammar.json +++ b/tree-sitter-osprey/src/grammar.json @@ -2905,6 +2905,47 @@ } ] }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "type_arguments", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_call_type_arguments" + }, + "named": true, + "value": "type_arguments" + } + }, + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "STRING", + "value": "(" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "argument_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, { "type": "SEQ", "members": [ @@ -3373,9 +3414,32 @@ "type_arguments": { "type": "SEQ", "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "STRING", + "value": "<" + } + }, + { + "type": "SYMBOL", + "name": "type_list" + }, { "type": "STRING", - "value": "<" + "value": ">" + } + ] + }, + "_call_type_arguments": { + "type": "SEQ", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "STRING", + "value": "<" + } }, { "type": "SYMBOL", diff --git a/tree-sitter-osprey/src/node-types.json b/tree-sitter-osprey/src/node-types.json index d3158c80..d7c31728 100644 --- a/tree-sitter-osprey/src/node-types.json +++ b/tree-sitter-osprey/src/node-types.json @@ -242,6 +242,16 @@ "named": true } ] + }, + "type_arguments": { + "multiple": false, + "required": false, + "types": [ + { + "type": "type_arguments", + "named": true + } + ] } }, "children": { diff --git a/tree-sitter-osprey/src/parser.c b/tree-sitter-osprey/src/parser.c index 514fce01..bba9b0e9 100644 --- a/tree-sitter-osprey/src/parser.c +++ b/tree-sitter-osprey/src/parser.c @@ -5,15 +5,15 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 1725 +#define STATE_COUNT 1751 #define LARGE_STATE_COUNT 21 -#define SYMBOL_COUNT 214 +#define SYMBOL_COUNT 217 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 83 +#define TOKEN_COUNT 85 #define EXTERNAL_TOKEN_COUNT 2 -#define FIELD_COUNT 48 +#define FIELD_COUNT 49 #define MAX_ALIAS_SEQUENCE_LENGTH 14 -#define PRODUCTION_ID_COUNT 192 +#define PRODUCTION_ID_COUNT 193 enum ts_symbol_identifiers { sym_identifier = 1, @@ -73,162 +73,165 @@ enum ts_symbol_identifiers { anon_sym_PERCENT = 55, anon_sym_await = 56, anon_sym_PIPE_GT = 57, - anon_sym_LBRACK2 = 58, - anon_sym_spawn = 59, - anon_sym_yield = 60, - anon_sym_send = 61, - anon_sym_recv = 62, - anon_sym_perform = 63, - anon_sym_resume = 64, - anon_sym_DOT_DOT = 65, - anon_sym_DOT_DOT_DOT = 66, - anon_sym_state = 67, - anon_sym_module = 68, - anon_sym_extra = 69, - anon_sym_export = 70, - anon_sym_opaque = 71, - anon_sym_signature = 72, - anon_sym_true = 73, - anon_sym_false = 74, - sym_float = 75, - sym_integer = 76, - sym_string = 77, - sym_interpolated_string = 78, - sym__doc_comment_line = 79, - sym_line_comment = 80, - sym__call_open_gap = 81, - sym__statement_break = 82, - sym_source_file = 83, - sym_statement = 84, - sym_import_statement = 85, - sym_legacy_import_path = 86, - sym_import_target = 87, - sym_import_tail = 88, - sym_import_member_list = 89, - sym_import_member = 90, - sym_namespace_name = 91, - sym_namespace_declaration = 92, - sym_namespace_body = 93, - sym_let_declaration = 94, - sym_assignment = 95, - sym_function_declaration = 96, - sym_extern_declaration = 97, - sym_extern_parameter_list = 98, - sym_extern_parameter = 99, - sym_parameter_list = 100, - sym_parameter = 101, - sym_type_declaration = 102, - sym_type_parameter_list = 103, - sym_type_parameter = 104, - sym_union_type = 105, - sym_type_alias = 106, - sym_variant = 107, - sym_positional_payload = 108, - sym_record_type = 109, - sym_field_declarations = 110, - sym_field_declaration = 111, - sym_type_validation = 112, - sym_effect_declaration = 113, - sym_multiplicity = 114, - sym_operation_declaration = 115, - sym_effect_set = 116, - sym_effect_list = 117, - sym_effect_ref = 118, - sym__type = 119, - sym_function_type = 120, - sym_generic_type = 121, - sym_array_type = 122, - sym_type_identifier = 123, - sym_type_list = 124, - sym_expression_statement = 125, - sym_expression = 126, - sym_match_expression = 127, - sym_match_arm = 128, - sym_if_expression = 129, - sym_handler_expression = 130, - sym_handler_arm = 131, - sym_handler_params = 132, - sym_kernel_expression = 133, - sym_kernel_arm = 134, - sym_select_expression = 135, - sym_select_arm = 136, - sym_ternary_expression = 137, - sym_binary_expression = 138, - sym_unary_expression = 139, - sym_pipe_expression = 140, - sym_call_expression = 141, - sym_argument_list = 142, - sym_named_argument_list = 143, - sym_named_argument = 144, - sym_primary_expression = 145, - sym_spawn_expression = 146, - sym_yield_expression = 147, - sym_await_call = 148, - sym_send_call = 149, - sym_recv_call = 150, - sym_perform_expression = 151, - sym_resume_expression = 152, - sym_type_constructor = 153, - sym_type_arguments = 154, - sym_update_expression = 155, - sym_field_assignments = 156, - sym_field_assignment = 157, - sym_block = 158, - sym_object_literal = 159, - sym_lambda_expression = 160, - sym_literal = 161, - sym_list_literal = 162, - sym_map_literal = 163, - sym_map_entry = 164, - sym_pattern = 165, - sym_structural_pattern = 166, - sym_tuple_pattern = 167, - sym_list_pattern = 168, - sym_field_pattern = 169, - sym_module_declaration = 170, - sym_signature_ascription = 171, - sym_module_item = 172, - sym_export_declaration = 173, - sym__module_declaration = 174, - sym_signature_declaration = 175, - sym_signature_item = 176, - sym_signature_value = 177, - sym_signature_function = 178, - sym_signature_type = 179, - sym_signature_module = 180, - sym_qualified_path = 181, - sym_symbol_path = 182, - sym_boolean = 183, - sym_doc_comment = 184, - aux_sym_source_file_repeat1 = 185, - aux_sym_legacy_import_path_repeat1 = 186, - aux_sym_import_target_repeat1 = 187, - aux_sym_import_member_list_repeat1 = 188, - aux_sym_extern_parameter_list_repeat1 = 189, - aux_sym_parameter_list_repeat1 = 190, - aux_sym_type_parameter_list_repeat1 = 191, - aux_sym_union_type_repeat1 = 192, - aux_sym_positional_payload_repeat1 = 193, - aux_sym_field_declarations_repeat1 = 194, - aux_sym_effect_declaration_repeat1 = 195, - aux_sym_effect_list_repeat1 = 196, - aux_sym_match_expression_repeat1 = 197, - aux_sym_handler_expression_repeat1 = 198, - aux_sym_handler_params_repeat1 = 199, - aux_sym_kernel_expression_repeat1 = 200, - aux_sym_select_expression_repeat1 = 201, - aux_sym_argument_list_repeat1 = 202, - aux_sym_named_argument_list_repeat1 = 203, - aux_sym_field_assignments_repeat1 = 204, - aux_sym_map_literal_repeat1 = 205, - aux_sym_pattern_repeat1 = 206, - aux_sym_tuple_pattern_repeat1 = 207, - aux_sym_list_pattern_repeat1 = 208, - aux_sym_field_pattern_repeat1 = 209, - aux_sym_module_declaration_repeat1 = 210, - aux_sym_signature_declaration_repeat1 = 211, - aux_sym_qualified_path_repeat1 = 212, - aux_sym_doc_comment_repeat1 = 213, + anon_sym_LPAREN2 = 58, + anon_sym_LBRACK2 = 59, + anon_sym_spawn = 60, + anon_sym_yield = 61, + anon_sym_send = 62, + anon_sym_recv = 63, + anon_sym_perform = 64, + anon_sym_resume = 65, + anon_sym_LT2 = 66, + anon_sym_DOT_DOT = 67, + anon_sym_DOT_DOT_DOT = 68, + anon_sym_state = 69, + anon_sym_module = 70, + anon_sym_extra = 71, + anon_sym_export = 72, + anon_sym_opaque = 73, + anon_sym_signature = 74, + anon_sym_true = 75, + anon_sym_false = 76, + sym_float = 77, + sym_integer = 78, + sym_string = 79, + sym_interpolated_string = 80, + sym__doc_comment_line = 81, + sym_line_comment = 82, + sym__call_open_gap = 83, + sym__statement_break = 84, + sym_source_file = 85, + sym_statement = 86, + sym_import_statement = 87, + sym_legacy_import_path = 88, + sym_import_target = 89, + sym_import_tail = 90, + sym_import_member_list = 91, + sym_import_member = 92, + sym_namespace_name = 93, + sym_namespace_declaration = 94, + sym_namespace_body = 95, + sym_let_declaration = 96, + sym_assignment = 97, + sym_function_declaration = 98, + sym_extern_declaration = 99, + sym_extern_parameter_list = 100, + sym_extern_parameter = 101, + sym_parameter_list = 102, + sym_parameter = 103, + sym_type_declaration = 104, + sym_type_parameter_list = 105, + sym_type_parameter = 106, + sym_union_type = 107, + sym_type_alias = 108, + sym_variant = 109, + sym_positional_payload = 110, + sym_record_type = 111, + sym_field_declarations = 112, + sym_field_declaration = 113, + sym_type_validation = 114, + sym_effect_declaration = 115, + sym_multiplicity = 116, + sym_operation_declaration = 117, + sym_effect_set = 118, + sym_effect_list = 119, + sym_effect_ref = 120, + sym__type = 121, + sym_function_type = 122, + sym_generic_type = 123, + sym_array_type = 124, + sym_type_identifier = 125, + sym_type_list = 126, + sym_expression_statement = 127, + sym_expression = 128, + sym_match_expression = 129, + sym_match_arm = 130, + sym_if_expression = 131, + sym_handler_expression = 132, + sym_handler_arm = 133, + sym_handler_params = 134, + sym_kernel_expression = 135, + sym_kernel_arm = 136, + sym_select_expression = 137, + sym_select_arm = 138, + sym_ternary_expression = 139, + sym_binary_expression = 140, + sym_unary_expression = 141, + sym_pipe_expression = 142, + sym_call_expression = 143, + sym_argument_list = 144, + sym_named_argument_list = 145, + sym_named_argument = 146, + sym_primary_expression = 147, + sym_spawn_expression = 148, + sym_yield_expression = 149, + sym_await_call = 150, + sym_send_call = 151, + sym_recv_call = 152, + sym_perform_expression = 153, + sym_resume_expression = 154, + sym_type_constructor = 155, + sym_type_arguments = 156, + sym__call_type_arguments = 157, + sym_update_expression = 158, + sym_field_assignments = 159, + sym_field_assignment = 160, + sym_block = 161, + sym_object_literal = 162, + sym_lambda_expression = 163, + sym_literal = 164, + sym_list_literal = 165, + sym_map_literal = 166, + sym_map_entry = 167, + sym_pattern = 168, + sym_structural_pattern = 169, + sym_tuple_pattern = 170, + sym_list_pattern = 171, + sym_field_pattern = 172, + sym_module_declaration = 173, + sym_signature_ascription = 174, + sym_module_item = 175, + sym_export_declaration = 176, + sym__module_declaration = 177, + sym_signature_declaration = 178, + sym_signature_item = 179, + sym_signature_value = 180, + sym_signature_function = 181, + sym_signature_type = 182, + sym_signature_module = 183, + sym_qualified_path = 184, + sym_symbol_path = 185, + sym_boolean = 186, + sym_doc_comment = 187, + aux_sym_source_file_repeat1 = 188, + aux_sym_legacy_import_path_repeat1 = 189, + aux_sym_import_target_repeat1 = 190, + aux_sym_import_member_list_repeat1 = 191, + aux_sym_extern_parameter_list_repeat1 = 192, + aux_sym_parameter_list_repeat1 = 193, + aux_sym_type_parameter_list_repeat1 = 194, + aux_sym_union_type_repeat1 = 195, + aux_sym_positional_payload_repeat1 = 196, + aux_sym_field_declarations_repeat1 = 197, + aux_sym_effect_declaration_repeat1 = 198, + aux_sym_effect_list_repeat1 = 199, + aux_sym_match_expression_repeat1 = 200, + aux_sym_handler_expression_repeat1 = 201, + aux_sym_handler_params_repeat1 = 202, + aux_sym_kernel_expression_repeat1 = 203, + aux_sym_select_expression_repeat1 = 204, + aux_sym_argument_list_repeat1 = 205, + aux_sym_named_argument_list_repeat1 = 206, + aux_sym_field_assignments_repeat1 = 207, + aux_sym_map_literal_repeat1 = 208, + aux_sym_pattern_repeat1 = 209, + aux_sym_tuple_pattern_repeat1 = 210, + aux_sym_list_pattern_repeat1 = 211, + aux_sym_field_pattern_repeat1 = 212, + aux_sym_module_declaration_repeat1 = 213, + aux_sym_signature_declaration_repeat1 = 214, + aux_sym_qualified_path_repeat1 = 215, + aux_sym_doc_comment_repeat1 = 216, }; static const char * const ts_symbol_names[] = { @@ -290,6 +293,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_PERCENT] = "%", [anon_sym_await] = "await", [anon_sym_PIPE_GT] = "|>", + [anon_sym_LPAREN2] = "(", [anon_sym_LBRACK2] = "[", [anon_sym_spawn] = "spawn", [anon_sym_yield] = "yield", @@ -297,6 +301,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_recv] = "recv", [anon_sym_perform] = "perform", [anon_sym_resume] = "resume", + [anon_sym_LT2] = "<", [anon_sym_DOT_DOT] = "..", [anon_sym_DOT_DOT_DOT] = "...", [anon_sym_state] = "state", @@ -387,6 +392,7 @@ static const char * const ts_symbol_names[] = { [sym_resume_expression] = "resume_expression", [sym_type_constructor] = "type_constructor", [sym_type_arguments] = "type_arguments", + [sym__call_type_arguments] = "type_arguments", [sym_update_expression] = "update_expression", [sym_field_assignments] = "field_assignments", [sym_field_assignment] = "field_assignment", @@ -507,6 +513,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_PERCENT] = anon_sym_PERCENT, [anon_sym_await] = anon_sym_await, [anon_sym_PIPE_GT] = anon_sym_PIPE_GT, + [anon_sym_LPAREN2] = anon_sym_LPAREN, [anon_sym_LBRACK2] = anon_sym_LBRACK, [anon_sym_spawn] = anon_sym_spawn, [anon_sym_yield] = anon_sym_yield, @@ -514,6 +521,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_recv] = anon_sym_recv, [anon_sym_perform] = anon_sym_perform, [anon_sym_resume] = anon_sym_resume, + [anon_sym_LT2] = anon_sym_LT, [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, [anon_sym_state] = anon_sym_state, @@ -604,6 +612,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_resume_expression] = sym_resume_expression, [sym_type_constructor] = sym_type_constructor, [sym_type_arguments] = sym_type_arguments, + [sym__call_type_arguments] = sym_type_arguments, [sym_update_expression] = sym_update_expression, [sym_field_assignments] = sym_field_assignments, [sym_field_assignment] = sym_field_assignment, @@ -898,6 +907,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_LPAREN2] = { + .visible = true, + .named = false, + }, [anon_sym_LBRACK2] = { .visible = true, .named = false, @@ -926,6 +939,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_LT2] = { + .visible = true, + .named = false, + }, [anon_sym_DOT_DOT] = { .visible = true, .named = false, @@ -1286,6 +1303,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym__call_type_arguments] = { + .visible = true, + .named = true, + }, [sym_update_expression] = { .visible = true, .named = true, @@ -1570,9 +1591,10 @@ enum ts_field_identifiers { field_target = 43, field_then = 44, field_type = 45, - field_type_parameters = 46, - field_value = 47, - field_variance = 48, + field_type_arguments = 46, + field_type_parameters = 47, + field_value = 48, + field_variance = 49, }; static const char * const ts_field_names[] = { @@ -1622,6 +1644,7 @@ static const char * const ts_field_names[] = { [field_target] = "target", [field_then] = "then", [field_type] = "type", + [field_type_arguments] = "type_arguments", [field_type_parameters] = "type_parameters", [field_value] = "value", [field_variance] = "variance", @@ -1661,164 +1684,165 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [31] = {.index = 49, .length = 2}, [32] = {.index = 51, .length = 2}, [33] = {.index = 53, .length = 2}, - [34] = {.index = 55, .length = 3}, - [35] = {.index = 58, .length = 1}, - [36] = {.index = 59, .length = 2}, + [34] = {.index = 55, .length = 2}, + [35] = {.index = 57, .length = 3}, + [36] = {.index = 60, .length = 1}, [37] = {.index = 61, .length = 2}, - [38] = {.index = 63, .length = 1}, - [39] = {.index = 64, .length = 2}, + [38] = {.index = 63, .length = 2}, + [39] = {.index = 65, .length = 1}, [40] = {.index = 66, .length = 2}, [41] = {.index = 68, .length = 2}, - [42] = {.index = 70, .length = 3}, - [43] = {.index = 73, .length = 1}, - [44] = {.index = 74, .length = 2}, - [45] = {.index = 76, .length = 3}, - [46] = {.index = 79, .length = 1}, - [47] = {.index = 80, .length = 3}, - [48] = {.index = 83, .length = 3}, - [49] = {.index = 86, .length = 3}, - [50] = {.index = 89, .length = 2}, + [42] = {.index = 70, .length = 2}, + [43] = {.index = 72, .length = 3}, + [44] = {.index = 75, .length = 1}, + [45] = {.index = 76, .length = 2}, + [46] = {.index = 78, .length = 3}, + [47] = {.index = 81, .length = 1}, + [48] = {.index = 82, .length = 3}, + [49] = {.index = 85, .length = 3}, + [50] = {.index = 88, .length = 3}, [51] = {.index = 91, .length = 2}, - [52] = {.index = 93, .length = 4}, - [53] = {.index = 97, .length = 1}, - [54] = {.index = 98, .length = 2}, - [55] = {.index = 100, .length = 3}, - [56] = {.index = 103, .length = 3}, - [57] = {.index = 106, .length = 2}, - [58] = {.index = 35, .length = 2}, - [59] = {.index = 108, .length = 3}, - [60] = {.index = 111, .length = 2}, - [61] = {.index = 113, .length = 3}, - [62] = {.index = 116, .length = 3}, - [63] = {.index = 119, .length = 2}, + [52] = {.index = 93, .length = 2}, + [53] = {.index = 95, .length = 4}, + [54] = {.index = 99, .length = 1}, + [55] = {.index = 100, .length = 2}, + [56] = {.index = 102, .length = 3}, + [57] = {.index = 105, .length = 3}, + [58] = {.index = 108, .length = 2}, + [59] = {.index = 35, .length = 2}, + [60] = {.index = 110, .length = 3}, + [61] = {.index = 113, .length = 2}, + [62] = {.index = 115, .length = 3}, + [63] = {.index = 118, .length = 3}, [64] = {.index = 121, .length = 2}, [65] = {.index = 123, .length = 2}, - [66] = {.index = 125, .length = 4}, - [67] = {.index = 129, .length = 2}, - [68] = {.index = 131, .length = 1}, - [69] = {.index = 132, .length = 2}, + [66] = {.index = 125, .length = 2}, + [67] = {.index = 127, .length = 4}, + [68] = {.index = 131, .length = 2}, + [69] = {.index = 133, .length = 1}, [70] = {.index = 134, .length = 2}, [71] = {.index = 136, .length = 2}, [72] = {.index = 138, .length = 2}, - [73] = {.index = 140, .length = 1}, - [74] = {.index = 141, .length = 2}, - [75] = {.index = 143, .length = 3}, - [76] = {.index = 146, .length = 3}, - [77] = {.index = 149, .length = 2}, - [78] = {.index = 151, .length = 1}, - [79] = {.index = 152, .length = 3}, - [80] = {.index = 155, .length = 3}, - [81] = {.index = 158, .length = 3}, - [82] = {.index = 161, .length = 4}, - [83] = {.index = 165, .length = 2}, + [73] = {.index = 140, .length = 2}, + [74] = {.index = 142, .length = 1}, + [75] = {.index = 143, .length = 2}, + [76] = {.index = 145, .length = 3}, + [77] = {.index = 148, .length = 3}, + [78] = {.index = 151, .length = 2}, + [79] = {.index = 153, .length = 1}, + [80] = {.index = 154, .length = 3}, + [81] = {.index = 157, .length = 3}, + [82] = {.index = 160, .length = 3}, + [83] = {.index = 163, .length = 4}, [84] = {.index = 167, .length = 2}, - [85] = {.index = 169, .length = 3}, - [86] = {.index = 172, .length = 3}, - [87] = {.index = 172, .length = 3}, - [88] = {.index = 175, .length = 3}, - [89] = {.index = 175, .length = 3}, - [90] = {.index = 178, .length = 2}, - [91] = {.index = 178, .length = 2}, + [85] = {.index = 169, .length = 2}, + [86] = {.index = 171, .length = 3}, + [87] = {.index = 174, .length = 3}, + [88] = {.index = 174, .length = 3}, + [89] = {.index = 177, .length = 3}, + [90] = {.index = 177, .length = 3}, + [91] = {.index = 180, .length = 2}, [92] = {.index = 180, .length = 2}, - [93] = {.index = 182, .length = 3}, - [94] = {.index = 185, .length = 4}, - [95] = {.index = 189, .length = 3}, - [96] = {.index = 192, .length = 2}, - [97] = {.index = 194, .length = 4}, - [98] = {.index = 198, .length = 2}, - [99] = {.index = 200, .length = 3}, - [100] = {.index = 203, .length = 3}, - [101] = {.index = 206, .length = 2}, - [102] = {.index = 208, .length = 4}, - [103] = {.index = 212, .length = 1}, - [104] = {.index = 213, .length = 3}, - [105] = {.index = 216, .length = 3}, - [106] = {.index = 219, .length = 4}, - [107] = {.index = 223, .length = 4}, - [108] = {.index = 227, .length = 4}, - [109] = {.index = 231, .length = 3}, - [110] = {.index = 234, .length = 3}, - [111] = {.index = 237, .length = 4}, - [112] = {.index = 237, .length = 4}, - [113] = {.index = 241, .length = 3}, - [114] = {.index = 241, .length = 3}, - [115] = {.index = 244, .length = 3}, - [116] = {.index = 244, .length = 3}, - [117] = {.index = 247, .length = 2}, + [93] = {.index = 182, .length = 2}, + [94] = {.index = 184, .length = 3}, + [95] = {.index = 187, .length = 4}, + [96] = {.index = 191, .length = 3}, + [97] = {.index = 194, .length = 2}, + [98] = {.index = 196, .length = 4}, + [99] = {.index = 200, .length = 2}, + [100] = {.index = 202, .length = 3}, + [101] = {.index = 205, .length = 3}, + [102] = {.index = 208, .length = 2}, + [103] = {.index = 210, .length = 4}, + [104] = {.index = 214, .length = 1}, + [105] = {.index = 215, .length = 3}, + [106] = {.index = 218, .length = 3}, + [107] = {.index = 221, .length = 4}, + [108] = {.index = 225, .length = 4}, + [109] = {.index = 229, .length = 4}, + [110] = {.index = 233, .length = 3}, + [111] = {.index = 236, .length = 3}, + [112] = {.index = 239, .length = 4}, + [113] = {.index = 239, .length = 4}, + [114] = {.index = 243, .length = 3}, + [115] = {.index = 243, .length = 3}, + [116] = {.index = 246, .length = 3}, + [117] = {.index = 246, .length = 3}, [118] = {.index = 249, .length = 2}, [119] = {.index = 251, .length = 2}, - [120] = {.index = 253, .length = 3}, - [121] = {.index = 256, .length = 1}, - [122] = {.index = 257, .length = 3}, - [123] = {.index = 260, .length = 3}, - [124] = {.index = 263, .length = 3}, - [125] = {.index = 266, .length = 4}, - [126] = {.index = 270, .length = 2}, - [127] = {.index = 272, .length = 3}, - [128] = {.index = 275, .length = 2}, - [129] = {.index = 277, .length = 3}, - [130] = {.index = 280, .length = 4}, - [131] = {.index = 284, .length = 4}, - [132] = {.index = 288, .length = 4}, - [133] = {.index = 292, .length = 4}, - [134] = {.index = 296, .length = 5}, - [135] = {.index = 301, .length = 4}, - [136] = {.index = 301, .length = 4}, - [137] = {.index = 305, .length = 3}, - [138] = {.index = 308, .length = 3}, - [139] = {.index = 311, .length = 2}, - [140] = {.index = 313, .length = 3}, - [141] = {.index = 316, .length = 3}, - [142] = {.index = 319, .length = 3}, - [143] = {.index = 322, .length = 3}, - [144] = {.index = 325, .length = 4}, - [145] = {.index = 329, .length = 4}, - [146] = {.index = 333, .length = 4}, - [147] = {.index = 337, .length = 3}, - [148] = {.index = 340, .length = 3}, - [149] = {.index = 343, .length = 4}, - [150] = {.index = 347, .length = 4}, - [151] = {.index = 351, .length = 4}, - [152] = {.index = 355, .length = 5}, - [153] = {.index = 360, .length = 5}, - [154] = {.index = 365, .length = 3}, - [155] = {.index = 368, .length = 3}, - [156] = {.index = 371, .length = 3}, - [157] = {.index = 374, .length = 4}, - [158] = {.index = 378, .length = 4}, - [159] = {.index = 382, .length = 4}, - [160] = {.index = 386, .length = 4}, - [161] = {.index = 390, .length = 5}, - [162] = {.index = 395, .length = 4}, - [163] = {.index = 399, .length = 5}, - [164] = {.index = 404, .length = 5}, - [165] = {.index = 409, .length = 5}, - [166] = {.index = 414, .length = 3}, - [167] = {.index = 417, .length = 3}, - [168] = {.index = 420, .length = 4}, - [169] = {.index = 424, .length = 4}, - [170] = {.index = 428, .length = 4}, - [171] = {.index = 432, .length = 4}, - [172] = {.index = 436, .length = 4}, - [173] = {.index = 440, .length = 5}, - [174] = {.index = 445, .length = 5}, - [175] = {.index = 450, .length = 5}, - [176] = {.index = 455, .length = 5}, - [177] = {.index = 460, .length = 6}, - [178] = {.index = 466, .length = 3}, - [179] = {.index = 469, .length = 4}, - [180] = {.index = 473, .length = 4}, - [181] = {.index = 477, .length = 5}, - [182] = {.index = 482, .length = 5}, - [183] = {.index = 487, .length = 5}, - [184] = {.index = 492, .length = 6}, - [185] = {.index = 498, .length = 4}, - [186] = {.index = 502, .length = 4}, - [187] = {.index = 506, .length = 5}, - [188] = {.index = 511, .length = 5}, - [189] = {.index = 516, .length = 6}, - [190] = {.index = 522, .length = 5}, - [191] = {.index = 527, .length = 6}, + [120] = {.index = 253, .length = 2}, + [121] = {.index = 255, .length = 3}, + [122] = {.index = 258, .length = 1}, + [123] = {.index = 259, .length = 3}, + [124] = {.index = 262, .length = 3}, + [125] = {.index = 265, .length = 3}, + [126] = {.index = 268, .length = 4}, + [127] = {.index = 272, .length = 2}, + [128] = {.index = 274, .length = 3}, + [129] = {.index = 277, .length = 2}, + [130] = {.index = 279, .length = 3}, + [131] = {.index = 282, .length = 4}, + [132] = {.index = 286, .length = 4}, + [133] = {.index = 290, .length = 4}, + [134] = {.index = 294, .length = 4}, + [135] = {.index = 298, .length = 5}, + [136] = {.index = 303, .length = 4}, + [137] = {.index = 303, .length = 4}, + [138] = {.index = 307, .length = 3}, + [139] = {.index = 310, .length = 3}, + [140] = {.index = 313, .length = 2}, + [141] = {.index = 315, .length = 3}, + [142] = {.index = 318, .length = 3}, + [143] = {.index = 321, .length = 3}, + [144] = {.index = 324, .length = 3}, + [145] = {.index = 327, .length = 4}, + [146] = {.index = 331, .length = 4}, + [147] = {.index = 335, .length = 4}, + [148] = {.index = 339, .length = 3}, + [149] = {.index = 342, .length = 3}, + [150] = {.index = 345, .length = 4}, + [151] = {.index = 349, .length = 4}, + [152] = {.index = 353, .length = 4}, + [153] = {.index = 357, .length = 5}, + [154] = {.index = 362, .length = 5}, + [155] = {.index = 367, .length = 3}, + [156] = {.index = 370, .length = 3}, + [157] = {.index = 373, .length = 3}, + [158] = {.index = 376, .length = 4}, + [159] = {.index = 380, .length = 4}, + [160] = {.index = 384, .length = 4}, + [161] = {.index = 388, .length = 4}, + [162] = {.index = 392, .length = 5}, + [163] = {.index = 397, .length = 4}, + [164] = {.index = 401, .length = 5}, + [165] = {.index = 406, .length = 5}, + [166] = {.index = 411, .length = 5}, + [167] = {.index = 416, .length = 3}, + [168] = {.index = 419, .length = 3}, + [169] = {.index = 422, .length = 4}, + [170] = {.index = 426, .length = 4}, + [171] = {.index = 430, .length = 4}, + [172] = {.index = 434, .length = 4}, + [173] = {.index = 438, .length = 4}, + [174] = {.index = 442, .length = 5}, + [175] = {.index = 447, .length = 5}, + [176] = {.index = 452, .length = 5}, + [177] = {.index = 457, .length = 5}, + [178] = {.index = 462, .length = 6}, + [179] = {.index = 468, .length = 3}, + [180] = {.index = 471, .length = 4}, + [181] = {.index = 475, .length = 4}, + [182] = {.index = 479, .length = 5}, + [183] = {.index = 484, .length = 5}, + [184] = {.index = 489, .length = 5}, + [185] = {.index = 494, .length = 6}, + [186] = {.index = 500, .length = 4}, + [187] = {.index = 504, .length = 4}, + [188] = {.index = 508, .length = 5}, + [189] = {.index = 513, .length = 5}, + [190] = {.index = 518, .length = 6}, + [191] = {.index = 524, .length = 5}, + [192] = {.index = 529, .length = 6}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -1908,630 +1932,633 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_callee, 0}, {field_index, 2}, [53] = + {field_callee, 0}, + {field_type_arguments, 1}, + [55] = {field_keyword, 1}, {field_name, 2}, - [55] = + [57] = {field_body, 3}, {field_keyword, 1}, {field_name, 2}, - [58] = + [60] = {field_body, 4}, - [59] = + [61] = {field_name, 1}, {field_variance, 0}, - [61] = + [63] = {field_body, 4}, {field_name, 1}, - [63] = + [65] = {field_name, 2}, - [64] = + [66] = {field_name, 2}, {field_stage, 0}, - [66] = + [68] = {field_body, 2}, {field_operation, 0}, - [68] = + [70] = {field_body, 4}, {field_effect, 1}, - [70] = + [72] = {field_body, 3}, {field_effect, 0}, {field_operation, 1}, - [73] = + [75] = {field_element, 1}, - [74] = + [76] = {field_body, 2}, {field_pattern, 0}, - [76] = + [78] = {field_keyword, 1}, {field_path, 2}, {field_state, 0}, - [79] = + [81] = {field_declaration, 1}, - [80] = + [82] = {field_keyword, 0}, {field_path, 1}, {field_signature, 2}, - [83] = + [85] = {field_condition, 0}, {field_else, 4}, {field_then, 2}, - [86] = + [88] = {field_keyword, 1}, {field_name, 2}, {field_value, 4}, - [89] = + [91] = {field_definition, 4}, {field_name, 2}, - [91] = + [93] = {field_keyword, 1}, {field_path, 2}, - [93] = + [95] = {field_keyword, 0}, {field_name, 1}, {field_type, 3}, {field_value, 5}, - [97] = + [99] = {field_body, 5}, - [98] = + [100] = {field_body, 5}, {field_name, 1}, - [100] = + [102] = {field_body, 5}, {field_effects, 4}, {field_name, 1}, - [103] = + [105] = {field_body, 5}, {field_name, 1}, {field_parameters, 3}, - [106] = + [108] = {field_name, 2}, {field_parameters, 4}, - [108] = + [110] = {field_body, 5}, {field_effect, 2}, {field_stage, 1}, - [111] = + [113] = {field_body, 3}, {field_operation, 0}, - [113] = + [115] = {field_body, 5}, {field_effect, 1}, {field_instantiation, 2}, - [116] = + [118] = {field_body, 4}, {field_effect, 0}, {field_operation, 1}, - [119] = + [121] = {field_element, 1}, {field_element, 2, .inherited = true}, - [121] = + [123] = {field_element, 0, .inherited = true}, {field_element, 1, .inherited = true}, - [123] = + [125] = {field_effect, 1}, {field_operation, 3}, - [125] = + [127] = {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, {field_state, 0}, - [129] = + [131] = {field_declaration, 2}, {field_opaque, 1}, - [131] = + [133] = {field_declaration, 2}, - [132] = + [134] = {field_extra, 3}, {field_path, 1}, - [134] = + [136] = {field_path, 1}, {field_signature, 2}, - [136] = + [138] = {field_name, 2}, {field_opaque, 0}, - [138] = + [140] = {field_body, 5}, {field_name, 2}, - [140] = + [142] = {field_name, 3}, - [141] = + [143] = {field_name, 3}, {field_stage, 1}, - [143] = + [145] = {field_keyword, 2}, {field_path, 3}, {field_state, 1}, - [146] = + [148] = {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, - [149] = + [151] = {field_alias, 2}, {field_name, 0}, - [151] = + [153] = {field_body, 6}, - [152] = + [154] = {field_body, 6}, {field_name, 1}, {field_return_type, 5}, - [155] = + [157] = {field_body, 6}, {field_effects, 4}, {field_name, 1}, - [158] = + [160] = {field_body, 6}, {field_name, 1}, {field_parameters, 3}, - [161] = + [163] = {field_body, 6}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [165] = + [167] = {field_name, 2}, {field_return_type, 6}, - [167] = + [169] = {field_name, 0}, {field_positional, 2}, - [169] = + [171] = {field_definition, 6}, {field_name, 1}, {field_type_parameters, 3}, - [172] = + [174] = {field_name, 1}, {field_replayable, 0}, {field_type, 3}, - [175] = + [177] = {field_multiplicity, 0}, {field_name, 1}, {field_type, 3}, - [178] = + [180] = {field_name, 1}, {field_type, 3}, - [180] = + [182] = {field_name, 1}, {field_type_parameters, 3}, - [182] = + [184] = {field_alternative, 6}, {field_condition, 1}, {field_consequence, 3}, - [185] = + [187] = {field_body, 6}, {field_effect, 2}, {field_instantiation, 3}, {field_stage, 1}, - [189] = + [191] = {field_effect, 1}, {field_instantiation, 2}, {field_operation, 4}, - [192] = + [194] = {field_declaration, 3}, {field_opaque, 2}, - [194] = + [196] = {field_keyword, 1}, {field_name, 2}, {field_type, 4}, {field_value, 6}, - [198] = + [200] = {field_body, 6}, {field_name, 2}, - [200] = + [202] = {field_body, 6}, {field_effects, 5}, {field_name, 2}, - [203] = + [205] = {field_body, 6}, {field_name, 2}, {field_parameters, 4}, - [206] = + [208] = {field_name, 3}, {field_parameters, 5}, - [208] = + [210] = {field_keyword, 2}, {field_path, 3}, {field_signature, 4}, {field_state, 1}, - [212] = + [214] = {field_body, 7}, - [213] = + [215] = {field_body, 7}, {field_name, 1}, {field_type_parameters, 3}, - [216] = + [218] = {field_body, 7}, {field_name, 1}, {field_return_type, 5}, - [219] = + [221] = {field_body, 7}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [223] = + [225] = {field_body, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [227] = + [229] = {field_body, 7}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [231] = + [233] = {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [234] = + [236] = {field_name, 2}, {field_stage, 0}, {field_type_parameters, 4}, - [237] = + [239] = {field_multiplicity, 0}, {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [241] = + [243] = {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [244] = + [246] = {field_multiplicity, 1}, {field_name, 2}, {field_type, 4}, - [247] = + [249] = {field_element, 1}, {field_rest, 4}, - [249] = + [251] = {field_effects, 4}, {field_name, 1}, - [251] = + [253] = {field_name, 1}, {field_parameters, 3}, - [253] = + [255] = {field_definition, 4}, {field_name, 2}, {field_opaque, 0}, - [256] = + [258] = {field_condition, 0}, - [257] = + [259] = {field_body, 7}, {field_name, 2}, {field_return_type, 6}, - [260] = + [262] = {field_body, 7}, {field_effects, 5}, {field_name, 2}, - [263] = + [265] = {field_body, 7}, {field_name, 2}, {field_parameters, 4}, - [266] = + [268] = {field_body, 7}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [270] = + [272] = {field_name, 3}, {field_return_type, 7}, - [272] = + [274] = {field_definition, 7}, {field_name, 2}, {field_type_parameters, 4}, - [275] = + [277] = {field_name, 2}, {field_type_parameters, 4}, - [277] = + [279] = {field_body, 8}, {field_name, 1}, {field_type_parameters, 3}, - [280] = + [282] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [284] = + [286] = {field_body, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [288] = + [290] = {field_body, 8}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [292] = + [294] = {field_body, 8}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [296] = + [298] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [301] = + [303] = {field_multiplicity, 1}, {field_name, 3}, {field_replayable, 2}, {field_type, 5}, - [305] = + [307] = {field_alternative, 7}, {field_condition, 1}, {field_consequence, 3}, - [308] = + [310] = {field_element, 1}, {field_element, 2, .inherited = true}, {field_rest, 5}, - [311] = + [313] = {field_name, 1}, {field_return_type, 5}, - [313] = + [315] = {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [316] = + [318] = {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [319] = + [321] = {field_body, 8}, {field_name, 2}, {field_type_parameters, 4}, - [322] = + [324] = {field_body, 8}, {field_name, 2}, {field_return_type, 6}, - [325] = + [327] = {field_body, 8}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [329] = + [331] = {field_body, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [333] = + [335] = {field_body, 8}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [337] = + [339] = {field_name, 3}, {field_parameters, 5}, {field_return_type, 8}, - [340] = + [342] = {field_name, 3}, {field_stage, 1}, {field_type_parameters, 5}, - [343] = + [345] = {field_body, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [347] = + [349] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [351] = + [353] = {field_body, 9}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [355] = + [357] = {field_body, 9}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [360] = + [362] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [365] = + [367] = {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [368] = + [370] = {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [371] = + [373] = {field_body, 9}, {field_name, 2}, {field_type_parameters, 4}, - [374] = + [376] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [378] = + [380] = {field_body, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [382] = + [384] = {field_body, 9}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [386] = + [388] = {field_body, 9}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [390] = + [392] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [395] = + [397] = {field_body, 10}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [399] = + [401] = {field_body, 10}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [404] = + [406] = {field_body, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [409] = + [411] = {field_body, 10}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [414] = + [416] = {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [417] = + [419] = {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [420] = + [422] = {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [424] = + [426] = {field_definition, 7}, {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [428] = + [430] = {field_body, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [432] = + [434] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [436] = + [438] = {field_body, 10}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [440] = + [442] = {field_body, 10}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [445] = + [447] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [450] = + [452] = {field_body, 11}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [455] = + [457] = {field_body, 11}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [460] = + [462] = {field_body, 11}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [466] = + [468] = {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [469] = + [471] = {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [473] = + [475] = {field_body, 11}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [477] = + [479] = {field_body, 11}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [482] = + [484] = {field_body, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [487] = + [489] = {field_body, 11}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [492] = + [494] = {field_body, 12}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [498] = + [500] = {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [502] = + [504] = {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [506] = + [508] = {field_body, 12}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [511] = + [513] = {field_body, 12}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [516] = + [518] = {field_body, 12}, {field_effects, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [522] = + [524] = {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [527] = + [529] = {field_body, 13}, {field_effects, 11}, {field_name, 2}, @@ -2542,28 +2569,28 @@ static const TSFieldMapEntry ts_field_map_entries[] = { static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { [0] = {0}, - [58] = { + [59] = { [0] = sym_identifier, }, - [86] = { + [87] = { [1] = sym_identifier, }, - [88] = { + [89] = { [1] = sym_identifier, }, - [90] = { + [91] = { [1] = sym_identifier, }, - [111] = { + [112] = { [2] = sym_identifier, }, - [113] = { + [114] = { [2] = sym_identifier, }, - [115] = { + [116] = { [2] = sym_identifier, }, - [135] = { + [136] = { [3] = sym_identifier, }, }; @@ -2587,41 +2614,41 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [8] = 8, [9] = 9, [10] = 10, - [11] = 7, - [12] = 5, - [13] = 13, + [11] = 6, + [12] = 6, + [13] = 6, [14] = 10, - [15] = 7, - [16] = 7, - [17] = 7, - [18] = 13, - [19] = 13, + [15] = 6, + [16] = 9, + [17] = 17, + [18] = 5, + [19] = 5, [20] = 20, [21] = 21, [22] = 22, [23] = 23, - [24] = 21, - [25] = 23, - [26] = 22, - [27] = 21, - [28] = 22, - [29] = 23, - [30] = 30, - [31] = 31, - [32] = 32, - [33] = 32, - [34] = 30, + [24] = 24, + [25] = 24, + [26] = 21, + [27] = 22, + [28] = 21, + [29] = 24, + [30] = 23, + [31] = 23, + [32] = 22, + [33] = 33, + [34] = 34, [35] = 35, - [36] = 31, - [37] = 35, - [38] = 32, - [39] = 31, - [40] = 40, - [41] = 30, - [42] = 35, - [43] = 43, - [44] = 44, - [45] = 45, + [36] = 36, + [37] = 33, + [38] = 38, + [39] = 36, + [40] = 34, + [41] = 35, + [42] = 33, + [43] = 34, + [44] = 35, + [45] = 36, [46] = 46, [47] = 47, [48] = 48, @@ -2637,7 +2664,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [58] = 58, [59] = 59, [60] = 60, - [61] = 61, + [61] = 46, [62] = 62, [63] = 63, [64] = 64, @@ -2647,7 +2674,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [68] = 68, [69] = 69, [70] = 70, - [71] = 43, + [71] = 71, [72] = 72, [73] = 73, [74] = 74, @@ -2677,135 +2704,135 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [98] = 98, [99] = 99, [100] = 100, - [101] = 100, + [101] = 101, [102] = 102, [103] = 103, [104] = 104, [105] = 105, [106] = 106, - [107] = 102, + [107] = 101, [108] = 108, [109] = 109, [110] = 110, [111] = 111, [112] = 112, [113] = 113, - [114] = 47, - [115] = 48, - [116] = 49, - [117] = 50, - [118] = 52, - [119] = 54, - [120] = 56, - [121] = 61, - [122] = 62, - [123] = 63, - [124] = 64, - [125] = 66, + [114] = 48, + [115] = 49, + [116] = 50, + [117] = 51, + [118] = 53, + [119] = 55, + [120] = 57, + [121] = 62, + [122] = 63, + [123] = 64, + [124] = 65, + [125] = 125, [126] = 67, [127] = 68, - [128] = 69, - [129] = 70, - [130] = 72, - [131] = 73, - [132] = 74, - [133] = 75, - [134] = 76, - [135] = 77, - [136] = 79, - [137] = 80, - [138] = 81, - [139] = 139, - [140] = 83, - [141] = 84, - [142] = 85, - [143] = 86, - [144] = 87, - [145] = 88, - [146] = 89, - [147] = 90, - [148] = 91, - [149] = 92, - [150] = 93, - [151] = 94, - [152] = 95, - [153] = 96, - [154] = 97, - [155] = 98, - [156] = 99, - [157] = 157, + [128] = 102, + [129] = 69, + [130] = 70, + [131] = 71, + [132] = 73, + [133] = 74, + [134] = 75, + [135] = 135, + [136] = 77, + [137] = 78, + [138] = 80, + [139] = 81, + [140] = 82, + [141] = 83, + [142] = 84, + [143] = 85, + [144] = 86, + [145] = 87, + [146] = 88, + [147] = 89, + [148] = 90, + [149] = 91, + [150] = 92, + [151] = 93, + [152] = 94, + [153] = 95, + [154] = 96, + [155] = 97, + [156] = 98, + [157] = 99, [158] = 100, - [159] = 102, - [160] = 103, - [161] = 104, - [162] = 105, - [163] = 106, - [164] = 109, - [165] = 110, - [166] = 111, - [167] = 112, - [168] = 113, - [169] = 47, - [170] = 50, - [171] = 54, - [172] = 56, - [173] = 61, - [174] = 64, - [175] = 68, - [176] = 72, - [177] = 103, - [178] = 157, - [179] = 104, - [180] = 180, - [181] = 51, - [182] = 105, - [183] = 106, - [184] = 184, - [185] = 185, + [159] = 159, + [160] = 101, + [161] = 102, + [162] = 103, + [163] = 104, + [164] = 105, + [165] = 106, + [166] = 109, + [167] = 110, + [168] = 111, + [169] = 112, + [170] = 113, + [171] = 48, + [172] = 51, + [173] = 55, + [174] = 57, + [175] = 62, + [176] = 65, + [177] = 69, + [178] = 73, + [179] = 103, + [180] = 159, + [181] = 104, + [182] = 182, + [183] = 59, + [184] = 105, + [185] = 106, [186] = 186, [187] = 187, - [188] = 65, - [189] = 157, - [190] = 180, - [191] = 51, + [188] = 188, + [189] = 189, + [190] = 125, + [191] = 159, [192] = 108, - [193] = 109, - [194] = 194, - [195] = 180, - [196] = 110, - [197] = 197, - [198] = 198, + [193] = 182, + [194] = 59, + [195] = 109, + [196] = 196, + [197] = 182, + [198] = 110, [199] = 111, [200] = 200, - [201] = 139, - [202] = 197, - [203] = 200, - [204] = 184, - [205] = 46, - [206] = 60, - [207] = 43, - [208] = 139, - [209] = 197, - [210] = 200, - [211] = 184, - [212] = 46, - [213] = 60, - [214] = 112, - [215] = 185, - [216] = 185, - [217] = 198, - [218] = 218, - [219] = 198, + [201] = 201, + [202] = 112, + [203] = 135, + [204] = 200, + [205] = 52, + [206] = 186, + [207] = 47, + [208] = 208, + [209] = 72, + [210] = 135, + [211] = 200, + [212] = 52, + [213] = 186, + [214] = 47, + [215] = 46, + [216] = 72, + [217] = 187, + [218] = 187, + [219] = 201, [220] = 113, - [221] = 65, - [222] = 82, + [221] = 221, + [222] = 201, [223] = 223, - [224] = 224, - [225] = 225, - [226] = 225, + [224] = 125, + [225] = 76, + [226] = 226, [227] = 227, [228] = 228, - [229] = 229, + [229] = 228, [230] = 230, [231] = 231, [232] = 232, @@ -2823,7 +2850,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [244] = 244, [245] = 245, [246] = 246, - [247] = 227, + [247] = 247, [248] = 248, [249] = 249, [250] = 250, @@ -2866,413 +2893,413 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [287] = 287, [288] = 288, [289] = 289, - [290] = 229, - [291] = 228, - [292] = 231, - [293] = 230, - [294] = 283, - [295] = 235, - [296] = 236, - [297] = 237, - [298] = 238, + [290] = 290, + [291] = 291, + [292] = 230, + [293] = 293, + [294] = 294, + [295] = 231, + [296] = 232, + [297] = 234, + [298] = 298, [299] = 299, [300] = 300, [301] = 301, - [302] = 243, - [303] = 244, - [304] = 245, - [305] = 246, + [302] = 302, + [303] = 303, + [304] = 304, + [305] = 305, [306] = 306, - [307] = 248, - [308] = 251, - [309] = 252, - [310] = 253, - [311] = 254, - [312] = 255, - [313] = 232, - [314] = 257, - [315] = 258, - [316] = 261, - [317] = 262, - [318] = 263, + [307] = 307, + [308] = 308, + [309] = 309, + [310] = 310, + [311] = 311, + [312] = 312, + [313] = 313, + [314] = 314, + [315] = 315, + [316] = 316, + [317] = 317, + [318] = 318, [319] = 319, - [320] = 264, - [321] = 265, - [322] = 266, - [323] = 267, - [324] = 268, - [325] = 269, - [326] = 270, - [327] = 271, + [320] = 320, + [321] = 321, + [322] = 322, + [323] = 323, + [324] = 324, + [325] = 325, + [326] = 326, + [327] = 327, [328] = 328, - [329] = 273, - [330] = 274, - [331] = 275, - [332] = 276, - [333] = 333, - [334] = 334, - [335] = 277, - [336] = 278, - [337] = 279, - [338] = 280, - [339] = 339, - [340] = 281, - [341] = 282, - [342] = 284, - [343] = 285, - [344] = 286, - [345] = 287, - [346] = 288, - [347] = 260, - [348] = 256, - [349] = 349, - [350] = 241, - [351] = 233, - [352] = 234, - [353] = 239, - [354] = 259, - [355] = 242, + [329] = 250, + [330] = 330, + [331] = 254, + [332] = 238, + [333] = 245, + [334] = 236, + [335] = 235, + [336] = 239, + [337] = 240, + [338] = 243, + [339] = 244, + [340] = 246, + [341] = 248, + [342] = 249, + [343] = 252, + [344] = 233, + [345] = 345, + [346] = 237, + [347] = 241, + [348] = 242, + [349] = 247, + [350] = 253, + [351] = 251, + [352] = 256, + [353] = 353, + [354] = 255, + [355] = 355, [356] = 356, - [357] = 357, - [358] = 358, - [359] = 359, - [360] = 360, - [361] = 361, - [362] = 362, - [363] = 363, - [364] = 364, - [365] = 365, - [366] = 366, - [367] = 367, - [368] = 368, - [369] = 369, - [370] = 370, - [371] = 371, - [372] = 372, - [373] = 373, - [374] = 374, - [375] = 375, - [376] = 376, - [377] = 377, - [378] = 378, - [379] = 250, - [380] = 240, - [381] = 249, - [382] = 382, - [383] = 383, - [384] = 384, - [385] = 272, - [386] = 289, - [387] = 387, - [388] = 388, - [389] = 229, - [390] = 228, - [391] = 231, - [392] = 392, - [393] = 393, + [357] = 293, + [358] = 263, + [359] = 294, + [360] = 274, + [361] = 275, + [362] = 276, + [363] = 277, + [364] = 278, + [365] = 264, + [366] = 279, + [367] = 280, + [368] = 281, + [369] = 265, + [370] = 282, + [371] = 266, + [372] = 283, + [373] = 284, + [374] = 267, + [375] = 285, + [376] = 268, + [377] = 260, + [378] = 257, + [379] = 286, + [380] = 287, + [381] = 273, + [382] = 288, + [383] = 289, + [384] = 261, + [385] = 290, + [386] = 258, + [387] = 291, + [388] = 262, + [389] = 270, + [390] = 269, + [391] = 259, + [392] = 271, + [393] = 272, [394] = 394, [395] = 395, - [396] = 392, - [397] = 397, - [398] = 398, + [396] = 232, + [397] = 231, + [398] = 255, [399] = 399, [400] = 400, [401] = 401, - [402] = 394, - [403] = 403, + [402] = 402, + [403] = 230, [404] = 404, [405] = 405, - [406] = 397, - [407] = 403, + [406] = 406, + [407] = 407, [408] = 408, - [409] = 395, + [409] = 409, [410] = 410, - [411] = 404, - [412] = 410, - [413] = 398, - [414] = 399, - [415] = 400, - [416] = 393, - [417] = 405, + [411] = 411, + [412] = 412, + [413] = 413, + [414] = 414, + [415] = 415, + [416] = 416, + [417] = 400, [418] = 418, [419] = 419, - [420] = 418, - [421] = 401, - [422] = 422, - [423] = 422, - [424] = 424, - [425] = 424, - [426] = 227, - [427] = 427, - [428] = 428, - [429] = 429, - [430] = 430, - [431] = 228, - [432] = 229, - [433] = 230, - [434] = 231, - [435] = 435, - [436] = 435, - [437] = 435, - [438] = 438, - [439] = 252, - [440] = 234, - [441] = 239, - [442] = 251, - [443] = 253, - [444] = 254, - [445] = 255, - [446] = 232, - [447] = 257, - [448] = 258, - [449] = 289, - [450] = 261, - [451] = 451, - [452] = 262, - [453] = 263, - [454] = 454, - [455] = 272, - [456] = 240, + [420] = 420, + [421] = 419, + [422] = 418, + [423] = 404, + [424] = 405, + [425] = 416, + [426] = 406, + [427] = 408, + [428] = 415, + [429] = 401, + [430] = 402, + [431] = 407, + [432] = 411, + [433] = 412, + [434] = 434, + [435] = 420, + [436] = 434, + [437] = 232, + [438] = 231, + [439] = 439, + [440] = 440, + [441] = 238, + [442] = 255, + [443] = 237, + [444] = 444, + [445] = 251, + [446] = 241, + [447] = 245, + [448] = 448, + [449] = 252, + [450] = 242, + [451] = 247, + [452] = 440, + [453] = 254, + [454] = 249, + [455] = 234, + [456] = 248, [457] = 457, - [458] = 249, - [459] = 264, - [460] = 265, - [461] = 461, - [462] = 266, - [463] = 259, - [464] = 267, - [465] = 268, - [466] = 466, - [467] = 269, - [468] = 270, - [469] = 469, - [470] = 271, - [471] = 235, - [472] = 273, - [473] = 274, - [474] = 236, - [475] = 475, - [476] = 275, - [477] = 242, - [478] = 243, - [479] = 244, - [480] = 276, - [481] = 481, - [482] = 245, - [483] = 483, - [484] = 278, - [485] = 279, - [486] = 280, - [487] = 281, - [488] = 246, - [489] = 250, - [490] = 237, - [491] = 282, - [492] = 283, - [493] = 284, - [494] = 285, - [495] = 238, - [496] = 286, - [497] = 497, - [498] = 287, - [499] = 288, - [500] = 260, - [501] = 256, - [502] = 457, - [503] = 475, - [504] = 497, - [505] = 454, - [506] = 248, - [507] = 241, - [508] = 457, - [509] = 475, - [510] = 497, - [511] = 454, - [512] = 233, + [458] = 253, + [459] = 233, + [460] = 250, + [461] = 246, + [462] = 256, + [463] = 440, + [464] = 457, + [465] = 236, + [466] = 235, + [467] = 457, + [468] = 239, + [469] = 240, + [470] = 243, + [471] = 244, + [472] = 472, + [473] = 258, + [474] = 283, + [475] = 293, + [476] = 284, + [477] = 273, + [478] = 270, + [479] = 261, + [480] = 279, + [481] = 285, + [482] = 280, + [483] = 294, + [484] = 267, + [485] = 274, + [486] = 281, + [487] = 287, + [488] = 266, + [489] = 489, + [490] = 490, + [491] = 262, + [492] = 275, + [493] = 259, + [494] = 263, + [495] = 264, + [496] = 496, + [497] = 276, + [498] = 498, + [499] = 282, + [500] = 288, + [501] = 289, + [502] = 502, + [503] = 503, + [504] = 504, + [505] = 490, + [506] = 506, + [507] = 504, + [508] = 257, + [509] = 286, + [510] = 272, + [511] = 489, + [512] = 512, [513] = 277, - [514] = 514, - [515] = 515, - [516] = 516, - [517] = 517, + [514] = 260, + [515] = 290, + [516] = 265, + [517] = 268, [518] = 518, - [519] = 519, - [520] = 520, - [521] = 521, - [522] = 522, - [523] = 522, - [524] = 524, - [525] = 525, - [526] = 524, - [527] = 527, - [528] = 527, - [529] = 529, - [530] = 522, - [531] = 531, - [532] = 532, + [519] = 504, + [520] = 490, + [521] = 504, + [522] = 504, + [523] = 291, + [524] = 278, + [525] = 269, + [526] = 271, + [527] = 317, + [528] = 345, + [529] = 324, + [530] = 530, + [531] = 356, + [532] = 319, [533] = 533, - [534] = 522, - [535] = 522, - [536] = 524, - [537] = 537, + [534] = 307, + [535] = 320, + [536] = 325, + [537] = 298, [538] = 538, - [539] = 376, - [540] = 360, - [541] = 541, - [542] = 300, - [543] = 362, - [544] = 363, - [545] = 545, + [539] = 539, + [540] = 540, + [541] = 330, + [542] = 542, + [543] = 543, + [544] = 544, + [545] = 530, [546] = 546, [547] = 547, - [548] = 365, - [549] = 366, - [550] = 367, - [551] = 368, - [552] = 333, - [553] = 374, - [554] = 375, - [555] = 377, - [556] = 370, - [557] = 371, + [548] = 548, + [549] = 549, + [550] = 550, + [551] = 551, + [552] = 299, + [553] = 553, + [554] = 353, + [555] = 321, + [556] = 546, + [557] = 326, [558] = 558, - [559] = 372, + [559] = 322, [560] = 560, - [561] = 229, - [562] = 373, - [563] = 334, - [564] = 564, - [565] = 565, - [566] = 378, - [567] = 567, - [568] = 382, - [569] = 383, - [570] = 570, - [571] = 384, - [572] = 349, - [573] = 339, - [574] = 357, - [575] = 558, - [576] = 576, - [577] = 577, - [578] = 578, - [579] = 579, - [580] = 538, - [581] = 545, - [582] = 356, - [583] = 359, - [584] = 577, - [585] = 547, - [586] = 578, - [587] = 564, - [588] = 369, - [589] = 589, - [590] = 364, - [591] = 591, - [592] = 558, - [593] = 306, - [594] = 576, - [595] = 577, - [596] = 578, - [597] = 538, - [598] = 545, - [599] = 358, - [600] = 547, - [601] = 589, - [602] = 564, - [603] = 589, - [604] = 319, - [605] = 328, - [606] = 606, - [607] = 299, - [608] = 301, - [609] = 579, - [610] = 541, - [611] = 361, - [612] = 579, - [613] = 541, - [614] = 576, - [615] = 231, - [616] = 616, + [561] = 539, + [562] = 553, + [563] = 563, + [564] = 300, + [565] = 327, + [566] = 563, + [567] = 318, + [568] = 539, + [569] = 302, + [570] = 303, + [571] = 571, + [572] = 543, + [573] = 544, + [574] = 530, + [575] = 546, + [576] = 560, + [577] = 548, + [578] = 549, + [579] = 304, + [580] = 551, + [581] = 553, + [582] = 543, + [583] = 544, + [584] = 560, + [585] = 563, + [586] = 305, + [587] = 306, + [588] = 355, + [589] = 548, + [590] = 590, + [591] = 328, + [592] = 308, + [593] = 301, + [594] = 551, + [595] = 309, + [596] = 323, + [597] = 310, + [598] = 311, + [599] = 549, + [600] = 312, + [601] = 313, + [602] = 558, + [603] = 542, + [604] = 604, + [605] = 558, + [606] = 542, + [607] = 314, + [608] = 315, + [609] = 316, + [610] = 610, + [611] = 611, + [612] = 612, + [613] = 613, + [614] = 614, + [615] = 615, + [616] = 613, [617] = 617, - [618] = 618, - [619] = 619, - [620] = 620, + [618] = 615, + [619] = 613, + [620] = 615, [621] = 621, [622] = 622, - [623] = 622, - [624] = 622, + [623] = 623, + [624] = 612, [625] = 625, - [626] = 620, - [627] = 620, - [628] = 228, + [626] = 612, + [627] = 627, + [628] = 628, [629] = 629, - [630] = 629, + [630] = 630, [631] = 631, [632] = 632, [633] = 633, - [634] = 631, - [635] = 632, - [636] = 633, + [634] = 634, + [635] = 635, + [636] = 636, [637] = 637, - [638] = 638, + [638] = 635, [639] = 639, - [640] = 640, + [640] = 639, [641] = 641, - [642] = 642, - [643] = 643, + [642] = 637, + [643] = 641, [644] = 644, [645] = 645, [646] = 646, [647] = 647, [648] = 648, - [649] = 428, + [649] = 649, [650] = 650, [651] = 651, [652] = 652, - [653] = 653, - [654] = 654, + [653] = 232, + [654] = 231, [655] = 655, [656] = 656, - [657] = 657, + [657] = 439, [658] = 658, [659] = 659, [660] = 660, - [661] = 652, - [662] = 662, + [661] = 661, + [662] = 659, [663] = 663, [664] = 664, [665] = 665, - [666] = 663, + [666] = 666, [667] = 667, [668] = 668, [669] = 669, [670] = 670, [671] = 671, [672] = 672, - [673] = 667, + [673] = 673, [674] = 674, [675] = 675, [676] = 676, [677] = 677, [678] = 678, - [679] = 654, + [679] = 679, [680] = 680, - [681] = 681, + [681] = 669, [682] = 682, [683] = 683, [684] = 684, - [685] = 685, - [686] = 686, + [685] = 255, + [686] = 675, [687] = 687, - [688] = 688, + [688] = 687, [689] = 689, [690] = 690, - [691] = 691, + [691] = 503, [692] = 692, [693] = 693, [694] = 694, [695] = 695, - [696] = 438, + [696] = 696, [697] = 697, [698] = 698, [699] = 699, @@ -3303,8 +3330,8 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [724] = 724, [725] = 725, [726] = 726, - [727] = 242, - [728] = 289, + [727] = 727, + [728] = 728, [729] = 729, [730] = 730, [731] = 731, @@ -3329,131 +3356,131 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [750] = 750, [751] = 751, [752] = 752, - [753] = 753, - [754] = 754, - [755] = 751, + [753] = 262, + [754] = 270, + [755] = 755, [756] = 756, [757] = 757, [758] = 758, [759] = 759, - [760] = 753, - [761] = 761, - [762] = 756, - [763] = 759, + [760] = 760, + [761] = 232, + [762] = 762, + [763] = 763, [764] = 764, [765] = 765, [766] = 766, [767] = 767, [768] = 768, - [769] = 766, - [770] = 767, - [771] = 765, - [772] = 772, - [773] = 773, - [774] = 764, + [769] = 769, + [770] = 770, + [771] = 771, + [772] = 760, + [773] = 231, + [774] = 232, [775] = 775, [776] = 776, [777] = 777, - [778] = 773, - [779] = 768, - [780] = 761, - [781] = 781, - [782] = 754, - [783] = 775, - [784] = 776, - [785] = 777, + [778] = 766, + [779] = 779, + [780] = 780, + [781] = 770, + [782] = 775, + [783] = 783, + [784] = 764, + [785] = 769, [786] = 786, [787] = 787, - [788] = 788, - [789] = 757, - [790] = 532, - [791] = 791, - [792] = 792, - [793] = 531, - [794] = 794, - [795] = 795, - [796] = 533, - [797] = 797, - [798] = 798, + [788] = 780, + [789] = 789, + [790] = 762, + [791] = 763, + [792] = 771, + [793] = 777, + [794] = 786, + [795] = 787, + [796] = 796, + [797] = 796, + [798] = 776, [799] = 799, - [800] = 515, + [800] = 783, [801] = 801, - [802] = 799, - [803] = 799, - [804] = 801, + [802] = 802, + [803] = 617, + [804] = 625, [805] = 805, - [806] = 537, - [807] = 801, - [808] = 808, - [809] = 809, - [810] = 810, - [811] = 811, + [806] = 806, + [807] = 622, + [808] = 623, + [809] = 611, + [810] = 255, + [811] = 255, [812] = 812, [813] = 813, [814] = 814, [815] = 815, - [816] = 811, - [817] = 817, - [818] = 817, - [819] = 815, + [816] = 814, + [817] = 815, + [818] = 818, + [819] = 814, [820] = 820, - [821] = 817, + [821] = 815, [822] = 822, [823] = 823, [824] = 824, - [825] = 825, + [825] = 231, [826] = 826, [827] = 827, [828] = 828, [829] = 829, [830] = 830, - [831] = 831, - [832] = 832, - [833] = 829, - [834] = 834, + [831] = 830, + [832] = 823, + [833] = 833, + [834] = 826, [835] = 835, [836] = 836, - [837] = 837, + [837] = 830, [838] = 838, - [839] = 828, + [839] = 839, [840] = 840, [841] = 841, [842] = 842, [843] = 843, - [844] = 829, - [845] = 845, + [844] = 844, + [845] = 621, [846] = 846, - [847] = 228, + [847] = 847, [848] = 848, - [849] = 229, + [849] = 849, [850] = 850, [851] = 851, [852] = 852, [853] = 853, - [854] = 518, + [854] = 854, [855] = 855, - [856] = 856, + [856] = 847, [857] = 857, - [858] = 842, + [858] = 858, [859] = 859, [860] = 860, [861] = 861, - [862] = 862, + [862] = 861, [863] = 863, [864] = 864, [865] = 865, - [866] = 866, - [867] = 867, - [868] = 838, - [869] = 869, - [870] = 862, - [871] = 864, + [866] = 231, + [867] = 232, + [868] = 868, + [869] = 851, + [870] = 870, + [871] = 871, [872] = 872, [873] = 873, - [874] = 874, + [874] = 851, [875] = 875, [876] = 876, - [877] = 828, + [877] = 877, [878] = 878, [879] = 879, [880] = 880, @@ -3464,60 +3491,60 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [885] = 885, [886] = 886, [887] = 887, - [888] = 888, - [889] = 889, - [890] = 890, + [888] = 861, + [889] = 846, + [890] = 868, [891] = 891, - [892] = 860, - [893] = 893, - [894] = 837, - [895] = 890, - [896] = 850, - [897] = 863, - [898] = 885, + [892] = 892, + [893] = 885, + [894] = 894, + [895] = 895, + [896] = 896, + [897] = 897, + [898] = 898, [899] = 899, - [900] = 869, - [901] = 830, - [902] = 861, - [903] = 865, + [900] = 900, + [901] = 901, + [902] = 902, + [903] = 903, [904] = 904, - [905] = 836, - [906] = 834, - [907] = 907, + [905] = 871, + [906] = 906, + [907] = 840, [908] = 908, - [909] = 837, - [910] = 910, - [911] = 890, - [912] = 863, - [913] = 874, - [914] = 914, - [915] = 915, - [916] = 916, - [917] = 917, - [918] = 842, - [919] = 904, + [909] = 909, + [910] = 857, + [911] = 896, + [912] = 912, + [913] = 913, + [914] = 904, + [915] = 841, + [916] = 865, + [917] = 870, + [918] = 892, + [919] = 900, [920] = 920, - [921] = 733, - [922] = 231, + [921] = 920, + [922] = 922, [923] = 923, - [924] = 924, - [925] = 925, - [926] = 926, - [927] = 927, - [928] = 928, - [929] = 929, + [924] = 840, + [925] = 847, + [926] = 886, + [927] = 839, + [928] = 896, + [929] = 839, [930] = 930, [931] = 931, - [932] = 930, - [933] = 933, + [932] = 932, + [933] = 912, [934] = 934, - [935] = 617, - [936] = 618, - [937] = 929, - [938] = 929, + [935] = 935, + [936] = 936, + [937] = 752, + [938] = 255, [939] = 939, [940] = 940, - [941] = 930, + [941] = 941, [942] = 942, [943] = 943, [944] = 944, @@ -3530,167 +3557,167 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [951] = 951, [952] = 952, [953] = 953, - [954] = 954, - [955] = 428, + [954] = 634, + [955] = 633, [956] = 956, [957] = 957, - [958] = 956, - [959] = 959, - [960] = 953, - [961] = 959, - [962] = 867, + [958] = 958, + [959] = 947, + [960] = 960, + [961] = 951, + [962] = 962, [963] = 963, [964] = 964, - [965] = 808, + [965] = 947, [966] = 966, - [967] = 967, - [968] = 966, - [969] = 969, - [970] = 957, - [971] = 964, - [972] = 969, - [973] = 954, + [967] = 951, + [968] = 968, + [969] = 818, + [970] = 970, + [971] = 971, + [972] = 972, + [973] = 973, [974] = 974, [975] = 975, [976] = 976, - [977] = 977, + [977] = 970, [978] = 978, - [979] = 979, - [980] = 980, + [979] = 973, + [980] = 439, [981] = 981, - [982] = 982, - [983] = 983, + [982] = 978, + [983] = 975, [984] = 984, - [985] = 758, - [986] = 986, - [987] = 987, - [988] = 988, - [989] = 989, - [990] = 990, + [985] = 984, + [986] = 895, + [987] = 981, + [988] = 974, + [989] = 976, + [990] = 767, [991] = 991, [992] = 992, - [993] = 989, + [993] = 993, [994] = 994, - [995] = 994, - [996] = 974, - [997] = 976, + [995] = 995, + [996] = 996, + [997] = 994, [998] = 998, [999] = 999, [1000] = 1000, [1001] = 1001, [1002] = 1002, - [1003] = 986, - [1004] = 991, - [1005] = 1000, - [1006] = 988, - [1007] = 787, - [1008] = 1008, - [1009] = 978, - [1010] = 638, - [1011] = 989, - [1012] = 998, - [1013] = 994, - [1014] = 992, + [1003] = 996, + [1004] = 1004, + [1005] = 644, + [1006] = 1006, + [1007] = 1007, + [1008] = 991, + [1009] = 1009, + [1010] = 1010, + [1011] = 1011, + [1012] = 1012, + [1013] = 1013, + [1014] = 1014, [1015] = 1015, [1016] = 1016, - [1017] = 999, - [1018] = 983, - [1019] = 1019, - [1020] = 1020, - [1021] = 990, - [1022] = 977, - [1023] = 1020, - [1024] = 1024, - [1025] = 1025, - [1026] = 1024, - [1027] = 975, - [1028] = 1016, - [1029] = 979, + [1017] = 1010, + [1018] = 1018, + [1019] = 1000, + [1020] = 1004, + [1021] = 1021, + [1022] = 998, + [1023] = 1011, + [1024] = 1021, + [1025] = 995, + [1026] = 1018, + [1027] = 1027, + [1028] = 1028, + [1029] = 1029, [1030] = 1030, - [1031] = 980, - [1032] = 1008, - [1033] = 1016, - [1034] = 1015, - [1035] = 1001, - [1036] = 1002, - [1037] = 999, - [1038] = 992, - [1039] = 1039, - [1040] = 1040, + [1031] = 1031, + [1032] = 1009, + [1033] = 1018, + [1034] = 1013, + [1035] = 1014, + [1036] = 1000, + [1037] = 779, + [1038] = 1029, + [1039] = 1021, + [1040] = 1030, [1041] = 1041, - [1042] = 1042, - [1043] = 1043, - [1044] = 1044, - [1045] = 639, - [1046] = 1039, - [1047] = 1047, + [1042] = 1041, + [1043] = 993, + [1044] = 1015, + [1045] = 1007, + [1046] = 1001, + [1047] = 1030, [1048] = 1048, - [1049] = 1040, - [1050] = 1044, - [1051] = 1051, - [1052] = 1052, + [1049] = 992, + [1050] = 1048, + [1051] = 995, + [1052] = 1012, [1053] = 1053, - [1054] = 1054, + [1054] = 1027, [1055] = 1055, [1056] = 1056, - [1057] = 1057, + [1057] = 647, [1058] = 1058, [1059] = 1059, - [1060] = 1060, + [1060] = 645, [1061] = 1061, [1062] = 1062, [1063] = 1063, - [1064] = 1048, - [1065] = 1058, + [1064] = 1064, + [1065] = 1065, [1066] = 1066, [1067] = 1067, - [1068] = 438, + [1068] = 1068, [1069] = 1069, [1070] = 1070, [1071] = 1071, [1072] = 1072, - [1073] = 1054, - [1074] = 640, - [1075] = 1044, - [1076] = 1055, - [1077] = 1077, + [1073] = 1073, + [1074] = 1074, + [1075] = 1075, + [1076] = 1065, + [1077] = 1070, [1078] = 1078, - [1079] = 1060, - [1080] = 1060, + [1079] = 1072, + [1080] = 1071, [1081] = 1081, - [1082] = 1055, - [1083] = 259, + [1082] = 1082, + [1083] = 1083, [1084] = 1084, [1085] = 1085, [1086] = 1086, - [1087] = 1087, + [1087] = 1063, [1088] = 1088, [1089] = 1089, - [1090] = 1048, - [1091] = 1091, + [1090] = 1090, + [1091] = 293, [1092] = 1092, - [1093] = 1077, - [1094] = 1094, - [1095] = 1040, + [1093] = 1093, + [1094] = 1063, + [1095] = 1095, [1096] = 1096, [1097] = 1097, - [1098] = 1098, + [1098] = 1064, [1099] = 1099, - [1100] = 887, - [1101] = 641, - [1102] = 1102, + [1100] = 1070, + [1101] = 1071, + [1102] = 1065, [1103] = 1103, [1104] = 1104, [1105] = 1105, - [1106] = 1106, - [1107] = 1107, - [1108] = 1108, - [1109] = 1109, + [1106] = 503, + [1107] = 1067, + [1108] = 880, + [1109] = 646, [1110] = 1110, - [1111] = 1111, + [1111] = 1110, [1112] = 1112, - [1113] = 1113, - [1114] = 1114, + [1113] = 1074, + [1114] = 1064, [1115] = 1115, [1116] = 1116, [1117] = 1117, @@ -3700,7 +3727,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1121] = 1121, [1122] = 1122, [1123] = 1123, - [1124] = 643, + [1124] = 1124, [1125] = 1125, [1126] = 1126, [1127] = 1127, @@ -3710,10 +3737,10 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1131] = 1131, [1132] = 1132, [1133] = 1133, - [1134] = 1134, + [1134] = 650, [1135] = 1135, [1136] = 1136, - [1137] = 1137, + [1137] = 1120, [1138] = 1138, [1139] = 1139, [1140] = 1140, @@ -3726,581 +3753,607 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1147] = 1147, [1148] = 1148, [1149] = 1149, - [1150] = 1150, - [1151] = 647, + [1150] = 1128, + [1151] = 1151, [1152] = 1152, - [1153] = 648, - [1154] = 1141, - [1155] = 1155, + [1153] = 1126, + [1154] = 1154, + [1155] = 1145, [1156] = 1156, - [1157] = 1157, + [1157] = 1131, [1158] = 1158, [1159] = 1159, - [1160] = 1160, + [1160] = 1156, [1161] = 1161, - [1162] = 1112, - [1163] = 1121, + [1162] = 1162, + [1163] = 1163, [1164] = 1164, [1165] = 1165, [1166] = 1166, - [1167] = 1167, - [1168] = 1165, - [1169] = 1102, + [1167] = 1124, + [1168] = 1168, + [1169] = 1169, [1170] = 1170, [1171] = 1171, - [1172] = 1106, - [1173] = 1173, - [1174] = 1174, + [1172] = 1172, + [1173] = 1132, + [1174] = 1132, [1175] = 1175, - [1176] = 646, + [1176] = 1176, [1177] = 1177, - [1178] = 1110, + [1178] = 1148, [1179] = 1179, - [1180] = 1156, - [1181] = 1113, + [1180] = 1164, + [1181] = 1181, [1182] = 1182, - [1183] = 1117, - [1184] = 1122, - [1185] = 1128, - [1186] = 1137, - [1187] = 1139, - [1188] = 1140, - [1189] = 1143, - [1190] = 1145, - [1191] = 1149, - [1192] = 1152, - [1193] = 1157, + [1183] = 1183, + [1184] = 1161, + [1185] = 1185, + [1186] = 1186, + [1187] = 1187, + [1188] = 1139, + [1189] = 1189, + [1190] = 1120, + [1191] = 1163, + [1192] = 1192, + [1193] = 1165, [1194] = 1194, - [1195] = 1102, - [1196] = 1196, - [1197] = 1152, + [1195] = 1195, + [1196] = 1159, + [1197] = 1189, [1198] = 1198, [1199] = 1199, [1200] = 1200, - [1201] = 1141, - [1202] = 1156, - [1203] = 1203, - [1204] = 1204, - [1205] = 1134, + [1201] = 1201, + [1202] = 1154, + [1203] = 1186, + [1204] = 1146, + [1205] = 1205, [1206] = 1206, - [1207] = 1182, - [1208] = 1208, + [1207] = 1207, + [1208] = 1201, [1209] = 1209, - [1210] = 1210, - [1211] = 1196, - [1212] = 1212, - [1213] = 1103, - [1214] = 1123, - [1215] = 1146, - [1216] = 1174, - [1217] = 1171, - [1218] = 1105, - [1219] = 1119, - [1220] = 1212, - [1221] = 1134, - [1222] = 1222, - [1223] = 1208, - [1224] = 1209, - [1225] = 1175, - [1226] = 1196, - [1227] = 1103, - [1228] = 1174, - [1229] = 1229, - [1230] = 1209, - [1231] = 1231, - [1232] = 1132, - [1233] = 1233, - [1234] = 1234, - [1235] = 1132, - [1236] = 1236, - [1237] = 642, - [1238] = 644, - [1239] = 1166, + [1210] = 656, + [1211] = 1144, + [1212] = 1206, + [1213] = 1213, + [1214] = 1214, + [1215] = 1215, + [1216] = 1216, + [1217] = 1217, + [1218] = 655, + [1219] = 1219, + [1220] = 648, + [1221] = 1221, + [1222] = 652, + [1223] = 1205, + [1224] = 1224, + [1225] = 1225, + [1226] = 1226, + [1227] = 1194, + [1228] = 1228, + [1229] = 1171, + [1230] = 649, + [1231] = 1164, + [1232] = 1168, + [1233] = 1189, + [1234] = 1125, + [1235] = 1200, + [1236] = 1154, + [1237] = 1237, + [1238] = 1205, + [1239] = 1209, [1240] = 1240, - [1241] = 645, + [1241] = 1241, [1242] = 1242, - [1243] = 1199, - [1244] = 1166, - [1245] = 1208, - [1246] = 533, - [1247] = 1247, - [1248] = 1248, + [1243] = 1194, + [1244] = 1148, + [1245] = 1179, + [1246] = 1169, + [1247] = 1119, + [1248] = 1179, [1249] = 1249, [1250] = 1250, - [1251] = 1159, - [1252] = 1252, - [1253] = 1253, + [1251] = 651, + [1252] = 1219, + [1253] = 1135, [1254] = 1254, [1255] = 1255, - [1256] = 1256, - [1257] = 1257, - [1258] = 657, - [1259] = 1259, - [1260] = 1260, - [1261] = 1261, + [1256] = 1213, + [1257] = 1127, + [1258] = 1219, + [1259] = 1170, + [1260] = 1200, + [1261] = 1209, [1262] = 1262, - [1263] = 857, - [1264] = 1264, + [1263] = 1263, + [1264] = 668, [1265] = 1265, [1266] = 1266, [1267] = 1267, - [1268] = 1268, + [1268] = 625, [1269] = 1269, - [1270] = 1265, + [1270] = 1270, [1271] = 1271, [1272] = 1272, - [1273] = 822, + [1273] = 1273, [1274] = 1274, - [1275] = 1275, + [1275] = 674, [1276] = 1276, [1277] = 1277, [1278] = 1278, [1279] = 1279, - [1280] = 1276, - [1281] = 659, + [1280] = 1280, + [1281] = 1281, [1282] = 1282, [1283] = 1283, [1284] = 1284, [1285] = 1285, [1286] = 1286, - [1287] = 515, - [1288] = 669, + [1287] = 1287, + [1288] = 611, [1289] = 1289, [1290] = 1290, - [1291] = 664, - [1292] = 1256, + [1291] = 1291, + [1292] = 891, [1293] = 1293, [1294] = 1294, - [1295] = 531, - [1296] = 532, + [1295] = 622, + [1296] = 923, [1297] = 1297, - [1298] = 1265, - [1299] = 1272, + [1298] = 671, + [1299] = 1273, [1300] = 1300, [1301] = 1301, - [1302] = 1302, - [1303] = 1271, - [1304] = 1286, - [1305] = 1305, - [1306] = 656, - [1307] = 1307, + [1302] = 1266, + [1303] = 1303, + [1304] = 1304, + [1305] = 663, + [1306] = 1262, + [1307] = 1286, [1308] = 1308, [1309] = 1309, [1310] = 1310, [1311] = 1311, - [1312] = 651, + [1312] = 660, [1313] = 1313, - [1314] = 1254, - [1315] = 1274, - [1316] = 1269, - [1317] = 1293, - [1318] = 1307, - [1319] = 1247, - [1320] = 1320, - [1321] = 1311, - [1322] = 1322, - [1323] = 1323, - [1324] = 1297, - [1325] = 1266, + [1314] = 1297, + [1315] = 1315, + [1316] = 1316, + [1317] = 833, + [1318] = 1318, + [1319] = 1308, + [1320] = 1290, + [1321] = 1321, + [1322] = 1265, + [1323] = 1316, + [1324] = 1324, + [1325] = 1324, [1326] = 1326, - [1327] = 1293, + [1327] = 1283, [1328] = 1328, - [1329] = 1257, - [1330] = 1330, - [1331] = 1285, + [1329] = 1329, + [1330] = 1287, + [1331] = 1331, [1332] = 1332, - [1333] = 537, - [1334] = 1322, - [1335] = 835, - [1336] = 1336, - [1337] = 1257, - [1338] = 1310, - [1339] = 1262, - [1340] = 1266, - [1341] = 1341, - [1342] = 1262, + [1333] = 1265, + [1334] = 1334, + [1335] = 1335, + [1336] = 1311, + [1337] = 1337, + [1338] = 1338, + [1339] = 1293, + [1340] = 1328, + [1341] = 1286, + [1342] = 1303, [1343] = 1343, - [1344] = 1344, + [1344] = 1237, [1345] = 1345, - [1346] = 1346, + [1346] = 623, [1347] = 1347, - [1348] = 1348, - [1349] = 1349, - [1350] = 731, - [1351] = 675, - [1352] = 1352, - [1353] = 1353, - [1354] = 1354, - [1355] = 1355, - [1356] = 1356, + [1348] = 1266, + [1349] = 1313, + [1350] = 1350, + [1351] = 1263, + [1352] = 1301, + [1353] = 617, + [1354] = 1313, + [1355] = 667, + [1356] = 1263, [1357] = 1357, - [1358] = 1358, + [1358] = 1321, [1359] = 1359, [1360] = 1360, [1361] = 1361, [1362] = 1362, [1363] = 1363, - [1364] = 1364, + [1364] = 736, [1365] = 1365, [1366] = 1366, [1367] = 1367, - [1368] = 732, - [1369] = 690, + [1368] = 1368, + [1369] = 1369, [1370] = 1370, [1371] = 1371, - [1372] = 1372, + [1372] = 717, [1373] = 1373, - [1374] = 650, + [1374] = 1374, [1375] = 1375, - [1376] = 1376, + [1376] = 737, [1377] = 1377, - [1378] = 1378, - [1379] = 1379, + [1378] = 695, + [1379] = 1375, [1380] = 1380, [1381] = 1381, [1382] = 1382, [1383] = 1383, - [1384] = 1384, + [1384] = 738, [1385] = 1385, [1386] = 1386, [1387] = 1387, - [1388] = 734, - [1389] = 691, - [1390] = 1390, - [1391] = 692, - [1392] = 735, + [1388] = 697, + [1389] = 739, + [1390] = 684, + [1391] = 1391, + [1392] = 1392, [1393] = 1393, - [1394] = 687, + [1394] = 1394, [1395] = 1395, - [1396] = 1359, - [1397] = 653, + [1396] = 658, + [1397] = 741, [1398] = 1398, - [1399] = 693, - [1400] = 1400, - [1401] = 1401, + [1399] = 1399, + [1400] = 742, + [1401] = 672, [1402] = 1402, [1403] = 1403, [1404] = 1404, [1405] = 1405, [1406] = 1406, - [1407] = 242, - [1408] = 1408, - [1409] = 694, - [1410] = 655, - [1411] = 1401, - [1412] = 1412, + [1407] = 1407, + [1408] = 698, + [1409] = 1409, + [1410] = 718, + [1411] = 699, + [1412] = 700, [1413] = 1413, - [1414] = 1402, - [1415] = 1415, - [1416] = 681, - [1417] = 736, - [1418] = 695, + [1414] = 743, + [1415] = 701, + [1416] = 1416, + [1417] = 1402, + [1418] = 722, [1419] = 1419, - [1420] = 1420, + [1420] = 744, [1421] = 1421, [1422] = 1422, [1423] = 1423, - [1424] = 1424, + [1424] = 1380, [1425] = 1425, - [1426] = 672, + [1426] = 1426, [1427] = 1427, [1428] = 1428, - [1429] = 697, - [1430] = 671, + [1429] = 745, + [1430] = 1430, [1431] = 1431, - [1432] = 678, - [1433] = 1433, - [1434] = 1434, + [1432] = 1387, + [1433] = 1394, + [1434] = 702, [1435] = 1435, - [1436] = 1436, - [1437] = 1437, + [1436] = 727, + [1437] = 746, [1438] = 1438, - [1439] = 1439, - [1440] = 682, - [1441] = 1441, + [1439] = 1404, + [1440] = 1435, + [1441] = 747, [1442] = 1442, - [1443] = 683, - [1444] = 1444, - [1445] = 684, - [1446] = 289, - [1447] = 1447, - [1448] = 1448, + [1443] = 1381, + [1444] = 1405, + [1445] = 1445, + [1446] = 703, + [1447] = 704, + [1448] = 1406, [1449] = 1449, - [1450] = 1450, - [1451] = 719, + [1450] = 750, + [1451] = 1451, [1452] = 1452, - [1453] = 1425, - [1454] = 685, - [1455] = 749, - [1456] = 699, + [1453] = 1453, + [1454] = 1454, + [1455] = 1455, + [1456] = 1456, [1457] = 1457, [1458] = 1458, - [1459] = 723, - [1460] = 1460, - [1461] = 1461, - [1462] = 1400, - [1463] = 700, + [1459] = 1360, + [1460] = 1382, + [1461] = 661, + [1462] = 1462, + [1463] = 1407, [1464] = 1464, - [1465] = 1371, - [1466] = 1354, + [1465] = 1465, + [1466] = 1466, [1467] = 1467, - [1468] = 701, - [1469] = 1347, - [1470] = 1435, + [1468] = 1468, + [1469] = 1469, + [1470] = 1470, [1471] = 1471, - [1472] = 702, - [1473] = 703, + [1472] = 1472, + [1473] = 1473, [1474] = 1474, - [1475] = 676, - [1476] = 1381, + [1475] = 673, + [1476] = 666, [1477] = 1477, - [1478] = 677, + [1478] = 1478, [1479] = 1479, - [1480] = 686, - [1481] = 704, + [1480] = 1480, + [1481] = 1481, [1482] = 1482, [1483] = 1483, - [1484] = 1484, - [1485] = 1471, - [1486] = 1486, + [1484] = 733, + [1485] = 1485, + [1486] = 1409, [1487] = 1487, - [1488] = 1452, + [1488] = 734, [1489] = 1489, [1490] = 1490, - [1491] = 1405, + [1491] = 1491, [1492] = 1492, - [1493] = 1360, - [1494] = 1361, - [1495] = 1362, - [1496] = 1366, - [1497] = 737, - [1498] = 738, - [1499] = 724, - [1500] = 1384, - [1501] = 1385, - [1502] = 1386, - [1503] = 1359, - [1504] = 1504, - [1505] = 1405, + [1493] = 1445, + [1494] = 705, + [1495] = 1495, + [1496] = 1451, + [1497] = 1490, + [1498] = 1498, + [1499] = 1482, + [1500] = 1500, + [1501] = 1501, + [1502] = 1502, + [1503] = 1503, + [1504] = 1370, + [1505] = 1416, [1506] = 1506, - [1507] = 1408, + [1507] = 1507, [1508] = 1508, - [1509] = 1425, - [1510] = 713, - [1511] = 875, - [1512] = 1435, - [1513] = 739, - [1514] = 1514, - [1515] = 1435, - [1516] = 705, - [1517] = 1435, - [1518] = 1479, - [1519] = 1519, - [1520] = 1382, - [1521] = 1521, - [1522] = 1378, - [1523] = 1523, - [1524] = 1523, - [1525] = 725, - [1526] = 1365, - [1527] = 1527, + [1509] = 1363, + [1510] = 1510, + [1511] = 740, + [1512] = 1512, + [1513] = 1363, + [1514] = 1375, + [1515] = 1380, + [1516] = 1381, + [1517] = 1382, + [1518] = 1386, + [1519] = 1386, + [1520] = 706, + [1521] = 262, + [1522] = 1404, + [1523] = 1405, + [1524] = 1406, + [1525] = 1416, + [1526] = 1526, + [1527] = 1425, [1528] = 1528, - [1529] = 1529, - [1530] = 715, - [1531] = 1408, - [1532] = 1532, + [1529] = 1428, + [1530] = 1530, + [1531] = 1445, + [1532] = 707, [1533] = 1533, - [1534] = 1534, - [1535] = 1434, - [1536] = 1536, - [1537] = 1537, - [1538] = 1482, - [1539] = 1539, - [1540] = 706, - [1541] = 1541, + [1534] = 1490, + [1535] = 1535, + [1536] = 755, + [1537] = 1490, + [1538] = 676, + [1539] = 1490, + [1540] = 1490, + [1541] = 1490, [1542] = 1542, [1543] = 1543, [1544] = 1544, - [1545] = 726, - [1546] = 1364, - [1547] = 750, + [1545] = 709, + [1546] = 1546, + [1547] = 710, [1548] = 1548, [1549] = 1549, - [1550] = 707, - [1551] = 1384, + [1550] = 1413, + [1551] = 711, [1552] = 1552, - [1553] = 1553, + [1553] = 756, [1554] = 1554, - [1555] = 688, - [1556] = 709, - [1557] = 1383, - [1558] = 1558, - [1559] = 1559, - [1560] = 662, - [1561] = 1561, - [1562] = 1385, - [1563] = 1386, - [1564] = 1490, - [1565] = 1508, - [1566] = 1566, - [1567] = 1567, - [1568] = 710, - [1569] = 740, + [1555] = 1555, + [1556] = 712, + [1557] = 1546, + [1558] = 270, + [1559] = 1487, + [1560] = 1560, + [1561] = 689, + [1562] = 1562, + [1563] = 713, + [1564] = 1362, + [1565] = 1565, + [1566] = 1419, + [1567] = 1455, + [1568] = 1562, + [1569] = 1569, [1570] = 1570, - [1571] = 1372, - [1572] = 1421, - [1573] = 689, - [1574] = 711, - [1575] = 1486, - [1576] = 1412, - [1577] = 741, - [1578] = 1559, - [1579] = 1413, - [1580] = 1380, - [1581] = 1398, - [1582] = 1458, - [1583] = 1554, - [1584] = 665, - [1585] = 1585, - [1586] = 1586, + [1571] = 1383, + [1572] = 1391, + [1573] = 1421, + [1574] = 714, + [1575] = 1422, + [1576] = 1576, + [1577] = 1577, + [1578] = 1491, + [1579] = 716, + [1580] = 677, + [1581] = 690, + [1582] = 1565, + [1583] = 1583, + [1584] = 1374, + [1585] = 1392, + [1586] = 1438, [1587] = 1587, [1588] = 1588, [1589] = 1589, - [1590] = 668, - [1591] = 1428, - [1592] = 1592, - [1593] = 1592, + [1590] = 1590, + [1591] = 1591, + [1592] = 1377, + [1593] = 670, [1594] = 1594, - [1595] = 742, - [1596] = 1360, - [1597] = 1567, - [1598] = 1431, - [1599] = 743, - [1600] = 1357, - [1601] = 744, + [1595] = 1393, + [1596] = 678, + [1597] = 1474, + [1598] = 708, + [1599] = 1599, + [1600] = 1501, + [1601] = 1601, [1602] = 1602, - [1603] = 660, - [1604] = 1604, + [1603] = 1603, + [1604] = 1395, [1605] = 1605, [1606] = 1606, - [1607] = 1378, - [1608] = 745, - [1609] = 1365, - [1610] = 1610, - [1611] = 1373, - [1612] = 712, - [1613] = 722, - [1614] = 1614, + [1607] = 1371, + [1608] = 1442, + [1609] = 1609, + [1610] = 1467, + [1611] = 1470, + [1612] = 1480, + [1613] = 1613, + [1614] = 664, [1615] = 1615, - [1616] = 1616, - [1617] = 1482, - [1618] = 1594, - [1619] = 1619, - [1620] = 1544, + [1616] = 1594, + [1617] = 1617, + [1618] = 1403, + [1619] = 1427, + [1620] = 1620, [1621] = 1621, - [1622] = 680, - [1623] = 1387, - [1624] = 746, - [1625] = 1367, - [1626] = 1420, - [1627] = 1375, - [1628] = 1400, - [1629] = 1490, - [1630] = 1361, - [1631] = 1567, - [1632] = 658, - [1633] = 1633, - [1634] = 1634, - [1635] = 1398, - [1636] = 1458, - [1637] = 1554, - [1638] = 1362, - [1639] = 747, - [1640] = 1427, + [1622] = 1622, + [1623] = 1543, + [1624] = 1624, + [1625] = 1624, + [1626] = 1626, + [1627] = 1627, + [1628] = 719, + [1629] = 1629, + [1630] = 1630, + [1631] = 1631, + [1632] = 1546, + [1633] = 1548, + [1634] = 1413, + [1635] = 720, + [1636] = 721, + [1637] = 1637, + [1638] = 1638, + [1639] = 1639, + [1640] = 679, [1641] = 1641, - [1642] = 748, - [1643] = 670, - [1644] = 1477, - [1645] = 1370, - [1646] = 1641, - [1647] = 1460, - [1648] = 1354, - [1649] = 1523, - [1650] = 1588, - [1651] = 1419, - [1652] = 714, - [1653] = 1585, - [1654] = 1461, - [1655] = 1423, - [1656] = 1561, - [1657] = 1657, - [1658] = 1435, + [1642] = 1562, + [1643] = 723, + [1644] = 1362, + [1645] = 1645, + [1646] = 1569, + [1647] = 1647, + [1648] = 1648, + [1649] = 724, + [1650] = 665, + [1651] = 1651, + [1652] = 1652, + [1653] = 725, + [1654] = 1605, + [1655] = 1589, + [1656] = 1656, + [1657] = 1377, + [1658] = 1589, [1659] = 1659, - [1660] = 1553, - [1661] = 1344, - [1662] = 1471, - [1663] = 1663, - [1664] = 1345, - [1665] = 1657, - [1666] = 1377, - [1667] = 1667, - [1668] = 1492, - [1669] = 1669, - [1670] = 1586, - [1671] = 1393, - [1672] = 1667, - [1673] = 1673, - [1674] = 1558, - [1675] = 1589, + [1660] = 1606, + [1661] = 1606, + [1662] = 1371, + [1663] = 1442, + [1664] = 726, + [1665] = 1665, + [1666] = 1666, + [1667] = 1555, + [1668] = 1668, + [1669] = 680, + [1670] = 1656, + [1671] = 1549, + [1672] = 1672, + [1673] = 1626, + [1674] = 1590, + [1675] = 1548, [1676] = 1676, - [1677] = 1663, - [1678] = 1477, - [1679] = 1370, - [1680] = 1381, - [1681] = 1461, - [1682] = 716, - [1683] = 1553, - [1684] = 1542, - [1685] = 1685, - [1686] = 1492, - [1687] = 1669, - [1688] = 1570, - [1689] = 1602, - [1690] = 1379, - [1691] = 1691, - [1692] = 1692, - [1693] = 717, - [1694] = 1694, - [1695] = 1415, - [1696] = 1376, - [1697] = 674, - [1698] = 1698, - [1699] = 1566, - [1700] = 1489, - [1701] = 1534, - [1702] = 1673, - [1703] = 1366, - [1704] = 1633, - [1705] = 1705, - [1706] = 1587, - [1707] = 1669, - [1708] = 1484, - [1709] = 1484, - [1710] = 1566, - [1711] = 1489, - [1712] = 1356, - [1713] = 1448, - [1714] = 1541, - [1715] = 730, - [1716] = 1344, - [1717] = 1544, - [1718] = 1356, - [1719] = 718, - [1720] = 1720, - [1721] = 1452, - [1722] = 1722, - [1723] = 1694, - [1724] = 1621, + [1677] = 1468, + [1678] = 757, + [1679] = 1425, + [1680] = 1554, + [1681] = 1457, + [1682] = 1682, + [1683] = 1471, + [1684] = 692, + [1685] = 693, + [1686] = 1641, + [1687] = 1385, + [1688] = 1477, + [1689] = 1533, + [1690] = 1552, + [1691] = 1676, + [1692] = 1485, + [1693] = 1482, + [1694] = 1659, + [1695] = 1454, + [1696] = 1366, + [1697] = 1535, + [1698] = 1622, + [1699] = 1478, + [1700] = 1373, + [1701] = 1399, + [1702] = 1702, + [1703] = 1569, + [1704] = 1656, + [1705] = 1549, + [1706] = 1666, + [1707] = 1554, + [1708] = 1409, + [1709] = 1641, + [1710] = 1385, + [1711] = 842, + [1712] = 1659, + [1713] = 1454, + [1714] = 1602, + [1715] = 1479, + [1716] = 1587, + [1717] = 728, + [1718] = 694, + [1719] = 1490, + [1720] = 1453, + [1721] = 1456, + [1722] = 1466, + [1723] = 1491, + [1724] = 1577, + [1725] = 1648, + [1726] = 1726, + [1727] = 1365, + [1728] = 729, + [1729] = 1542, + [1730] = 1465, + [1731] = 759, + [1732] = 1451, + [1733] = 730, + [1734] = 1734, + [1735] = 731, + [1736] = 1648, + [1737] = 1360, + [1738] = 1530, + [1739] = 732, + [1740] = 682, + [1741] = 1741, + [1742] = 683, + [1743] = 1743, + [1744] = 1530, + [1745] = 1745, + [1746] = 735, + [1747] = 1370, + [1748] = 1426, + [1749] = 1428, + [1750] = 715, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -4313,8 +4366,8 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '!', 68, '"', 12, '%', 84, - '&', 20, - '(', 62, + '&', 21, + '(', 86, ')', 63, '*', 50, '+', 79, @@ -4324,11 +4377,11 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '/', 82, ':', 53, ';', 52, - '<', 59, + '<', 88, '=', 56, '>', 61, '?', 72, - '[', 86, + '[', 87, ']', 70, '{', 48, '|', 66, @@ -4336,13 +4389,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(40); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 1: - if (lookahead == '\n') ADVANCE(19); + if (lookahead == '\n') ADVANCE(20); if (lookahead == '"') ADVANCE(14); if (lookahead == '$') ADVANCE(15); if (lookahead == '\\') ADVANCE(2); @@ -4350,25 +4403,25 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 2: if (lookahead == '\n') ADVANCE(14); - if (lookahead == '"') ADVANCE(94); + if (lookahead == '"') ADVANCE(96); if (lookahead == '\\') ADVANCE(1); if (lookahead != 0) ADVANCE(12); END_STATE(); case 3: if (lookahead == '\n') ADVANCE(14); - if (lookahead == '"') ADVANCE(93); + if (lookahead == '"') ADVANCE(95); if (lookahead == '\\') ADVANCE(5); if (lookahead != 0) ADVANCE(13); END_STATE(); case 4: if (lookahead == '\n') ADVANCE(33); if (lookahead == '}') ADVANCE(13); - if (lookahead != 0) ADVANCE(16); + if (lookahead != 0) ADVANCE(17); END_STATE(); case 5: - if (lookahead == '\n') ADVANCE(17); - if (lookahead == '"') ADVANCE(97); - if (lookahead == '$') ADVANCE(18); + if (lookahead == '\n') ADVANCE(18); + if (lookahead == '"') ADVANCE(99); + if (lookahead == '$') ADVANCE(19); if (lookahead == '\\') ADVANCE(3); if (lookahead != 0) ADVANCE(13); END_STATE(); @@ -4377,7 +4430,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '!', 68, '"', 12, '%', 84, - '&', 20, + '&', 21, '(', 62, '*', 50, '+', 79, @@ -4385,28 +4438,28 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '.', 45, '/', 82, ':', 27, - '<', 59, + '<', 88, '=', 28, '>', 61, '?', 72, - '[', 86, + '[', 87, '{', 48, '|', 66, '}', 49, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(7); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 7: ADVANCE_MAP( '!', 68, '"', 12, '%', 84, - '&', 20, + '&', 21, '(', 62, '*', 50, '+', 79, @@ -4425,10 +4478,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(7); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 8: ADVANCE_MAP( @@ -4453,37 +4506,21 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(8); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 9: - ADVANCE_MAP( - '!', 67, - '"', 14, - '(', 62, - ')', 63, - '+', 79, - ',', 51, - '-', 29, - '.', 45, - '/', 26, - ':', 53, - '<', 58, - '=', 57, - '>', 60, - '[', 69, - ']', 70, - '{', 48, - '|', 65, - '}', 49, - ); + if (lookahead == '!') ADVANCE(67); + if (lookahead == '(') ADVANCE(86); + if (lookahead == '-') ADVANCE(29); + if (lookahead == '/') ADVANCE(26); + if (lookahead == '<') ADVANCE(58); + if (lookahead == '=') ADVANCE(54); + if (lookahead == '{') ADVANCE(48); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(9); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + lookahead == ' ') SKIP(11); END_STATE(); case 10: if (lookahead == '!') ADVANCE(67); @@ -4494,69 +4531,44 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ') SKIP(10); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 11: if (lookahead == '!') ADVANCE(67); if (lookahead == '-') ADVANCE(29); if (lookahead == '/') ADVANCE(26); + if (lookahead == '<') ADVANCE(58); if (lookahead == '=') ADVANCE(54); if (lookahead == '{') ADVANCE(48); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(11); END_STATE(); case 12: - if (lookahead == '"') ADVANCE(92); + if (lookahead == '"') ADVANCE(94); if (lookahead == '$') ADVANCE(15); if (lookahead == '\\') ADVANCE(35); if (lookahead != 0) ADVANCE(12); END_STATE(); case 13: - if (lookahead == '"') ADVANCE(92); - if (lookahead == '$') ADVANCE(18); + if (lookahead == '"') ADVANCE(94); + if (lookahead == '$') ADVANCE(19); if (lookahead == '\\') ADVANCE(39); if (lookahead != 0) ADVANCE(13); END_STATE(); case 14: - if (lookahead == '"') ADVANCE(92); + if (lookahead == '"') ADVANCE(94); if (lookahead == '\\') ADVANCE(37); if (lookahead != 0) ADVANCE(14); END_STATE(); case 15: - if (lookahead == '"') ADVANCE(94); + if (lookahead == '"') ADVANCE(96); if (lookahead == '\\') ADVANCE(1); - if (lookahead == '{') ADVANCE(16); + if (lookahead == '{') ADVANCE(17); if (lookahead != 0) ADVANCE(12); END_STATE(); case 16: - if (lookahead == '"') ADVANCE(95); - if (lookahead == '\\') ADVANCE(4); - if (lookahead == '}') ADVANCE(13); - if (lookahead != 0) ADVANCE(16); - END_STATE(); - case 17: - if (lookahead == '"') ADVANCE(96); - if (lookahead == '$') ADVANCE(32); - if (lookahead == '\\') ADVANCE(38); - if (lookahead != 0) ADVANCE(17); - END_STATE(); - case 18: - if (lookahead == '"') ADVANCE(93); - if (lookahead == '\\') ADVANCE(5); - if (lookahead == '{') ADVANCE(16); - if (lookahead != 0) ADVANCE(13); - END_STATE(); - case 19: - if (lookahead == '$') ADVANCE(31); - if (lookahead == '\\') ADVANCE(36); - if (lookahead != 0 && - lookahead != '"') ADVANCE(19); - END_STATE(); - case 20: - if (lookahead == '&') ADVANCE(74); - END_STATE(); - case 21: ADVANCE_MAP( + '"', 14, '(', 62, ')', 63, ',', 51, @@ -4570,25 +4582,52 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '}', 49, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(21); + lookahead == ' ') SKIP(16); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + END_STATE(); + case 17: + if (lookahead == '"') ADVANCE(97); + if (lookahead == '\\') ADVANCE(4); + if (lookahead == '}') ADVANCE(13); + if (lookahead != 0) ADVANCE(17); + END_STATE(); + case 18: + if (lookahead == '"') ADVANCE(98); + if (lookahead == '$') ADVANCE(32); + if (lookahead == '\\') ADVANCE(38); + if (lookahead != 0) ADVANCE(18); + END_STATE(); + case 19: + if (lookahead == '"') ADVANCE(95); + if (lookahead == '\\') ADVANCE(5); + if (lookahead == '{') ADVANCE(17); + if (lookahead != 0) ADVANCE(13); + END_STATE(); + case 20: + if (lookahead == '$') ADVANCE(31); + if (lookahead == '\\') ADVANCE(36); + if (lookahead != 0 && + lookahead != '"') ADVANCE(20); + END_STATE(); + case 21: + if (lookahead == '&') ADVANCE(74); END_STATE(); case 22: - if (lookahead == '.') ADVANCE(89); + if (lookahead == '.') ADVANCE(91); END_STATE(); case 23: - if (lookahead == '.') ADVANCE(87); + if (lookahead == '.') ADVANCE(89); END_STATE(); case 24: if (lookahead == '.') ADVANCE(22); END_STATE(); case 25: - if (lookahead == '/') ADVANCE(100); + if (lookahead == '/') ADVANCE(102); END_STATE(); case 26: - if (lookahead == '/') ADVANCE(101); + if (lookahead == '/') ADVANCE(103); END_STATE(); case 27: if (lookahead == ':') ADVANCE(47); @@ -4604,18 +4643,18 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 31: if (lookahead == '{') ADVANCE(33); - if (lookahead != 0) ADVANCE(19); + if (lookahead != 0) ADVANCE(20); END_STATE(); case 32: if (lookahead == '{') ADVANCE(33); - if (lookahead != 0) ADVANCE(17); + if (lookahead != 0) ADVANCE(18); END_STATE(); case 33: - if (lookahead == '}') ADVANCE(17); + if (lookahead == '}') ADVANCE(18); if (lookahead != 0) ADVANCE(33); END_STATE(); case 34: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(90); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); END_STATE(); case 35: if (lookahead != 0 && @@ -4623,7 +4662,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 36: if (lookahead != 0 && - lookahead != '\n') ADVANCE(19); + lookahead != '\n') ADVANCE(20); END_STATE(); case 37: if (lookahead != 0 && @@ -4631,7 +4670,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 38: if (lookahead != 0 && - lookahead != '\n') ADVANCE(17); + lookahead != '\n') ADVANCE(18); END_STATE(); case 39: if (lookahead != 0 && @@ -4643,7 +4682,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '!', 68, '"', 12, '%', 84, - '&', 20, + '&', 21, '(', 62, ')', 63, '*', 50, @@ -4666,10 +4705,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(40); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 41: if (eof) ADVANCE(44); @@ -4677,7 +4716,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '!', 68, '"', 12, '%', 84, - '&', 20, + '&', 21, '(', 62, ')', 63, '*', 50, @@ -4688,11 +4727,11 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '/', 83, ':', 53, ';', 52, - '<', 59, + '<', 88, '=', 55, '>', 61, '?', 72, - '[', 86, + '[', 87, ']', 70, '{', 48, '|', 66, @@ -4700,10 +4739,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(42); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 42: if (eof) ADVANCE(44); @@ -4711,7 +4750,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '!', 68, '"', 12, '%', 84, - '&', 20, + '&', 21, '(', 62, ')', 63, '*', 50, @@ -4734,10 +4773,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(42); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 43: if (eof) ADVANCE(44); @@ -4758,10 +4797,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(43); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); case 44: ACCEPT_TOKEN(ts_builtin_sym_end); @@ -4771,7 +4810,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 46: ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(88); + if (lookahead == '.') ADVANCE(90); END_STATE(); case 47: ACCEPT_TOKEN(anon_sym_COLON_COLON); @@ -4891,11 +4930,11 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 82: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(100); + if (lookahead == '/') ADVANCE(102); END_STATE(); case 83: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(101); + if (lookahead == '/') ADVANCE(103); END_STATE(); case 84: ACCEPT_TOKEN(anon_sym_PERCENT); @@ -4904,83 +4943,90 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ACCEPT_TOKEN(anon_sym_PIPE_GT); END_STATE(); case 86: - ACCEPT_TOKEN(anon_sym_LBRACK2); + ACCEPT_TOKEN(anon_sym_LPAREN2); END_STATE(); case 87: - ACCEPT_TOKEN(anon_sym_DOT_DOT); + ACCEPT_TOKEN(anon_sym_LBRACK2); END_STATE(); case 88: - ACCEPT_TOKEN(anon_sym_DOT_DOT); - if (lookahead == '.') ADVANCE(89); + ACCEPT_TOKEN(anon_sym_LT2); + if (lookahead == '=') ADVANCE(77); END_STATE(); case 89: - ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + ACCEPT_TOKEN(anon_sym_DOT_DOT); END_STATE(); case 90: - ACCEPT_TOKEN(sym_float); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(90); + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '.') ADVANCE(91); END_STATE(); case 91: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 92: + ACCEPT_TOKEN(sym_float); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + END_STATE(); + case 93: ACCEPT_TOKEN(sym_integer); if (lookahead == '.') ADVANCE(34); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); END_STATE(); - case 92: + case 94: ACCEPT_TOKEN(sym_string); END_STATE(); - case 93: + case 95: ACCEPT_TOKEN(sym_string); - if (lookahead == '"') ADVANCE(96); + if (lookahead == '"') ADVANCE(98); if (lookahead == '$') ADVANCE(32); if (lookahead == '\\') ADVANCE(38); - if (lookahead != 0) ADVANCE(17); + if (lookahead != 0) ADVANCE(18); END_STATE(); - case 94: + case 96: ACCEPT_TOKEN(sym_string); if (lookahead == '$') ADVANCE(31); if (lookahead == '\\') ADVANCE(36); if (lookahead != 0 && - lookahead != '"') ADVANCE(19); + lookahead != '"') ADVANCE(20); END_STATE(); - case 95: + case 97: ACCEPT_TOKEN(sym_string); - if (lookahead == '}') ADVANCE(17); + if (lookahead == '}') ADVANCE(18); if (lookahead != 0) ADVANCE(33); END_STATE(); - case 96: + case 98: ACCEPT_TOKEN(sym_interpolated_string); END_STATE(); - case 97: + case 99: ACCEPT_TOKEN(sym_interpolated_string); - if (lookahead == '"') ADVANCE(92); + if (lookahead == '"') ADVANCE(94); if (lookahead == '\\') ADVANCE(37); if (lookahead != 0) ADVANCE(14); END_STATE(); - case 98: + case 100: ACCEPT_TOKEN(sym_identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(98); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); END_STATE(); - case 99: + case 101: ACCEPT_TOKEN(sym__doc_comment_line); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(99); + lookahead != '\r') ADVANCE(101); END_STATE(); - case 100: + case 102: ACCEPT_TOKEN(sym_line_comment); - if (lookahead == '/') ADVANCE(99); + if (lookahead == '/') ADVANCE(101); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(101); + lookahead != '\r') ADVANCE(103); END_STATE(); - case 101: + case 103: ACCEPT_TOKEN(sym_line_comment); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(101); + lookahead != '\r') ADVANCE(103); END_STATE(); default: return false; @@ -5527,7 +5573,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [2] = {.lex_state = 43}, [3] = {.lex_state = 43}, [4] = {.lex_state = 43}, - [5] = {.lex_state = 43}, + [5] = {.lex_state = 6, .external_lex_state = 2}, [6] = {.lex_state = 43}, [7] = {.lex_state = 43}, [8] = {.lex_state = 43}, @@ -5535,7 +5581,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [10] = {.lex_state = 43}, [11] = {.lex_state = 43}, [12] = {.lex_state = 43}, - [13] = {.lex_state = 6, .external_lex_state = 2}, + [13] = {.lex_state = 43}, [14] = {.lex_state = 43}, [15] = {.lex_state = 43}, [16] = {.lex_state = 43}, @@ -5745,13 +5791,13 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [220] = {.lex_state = 8}, [221] = {.lex_state = 8}, [222] = {.lex_state = 8}, - [223] = {.lex_state = 43}, - [224] = {.lex_state = 43}, - [225] = {.lex_state = 43}, + [223] = {.lex_state = 8}, + [224] = {.lex_state = 8}, + [225] = {.lex_state = 8}, [226] = {.lex_state = 43}, - [227] = {.lex_state = 41, .external_lex_state = 2}, - [228] = {.lex_state = 41, .external_lex_state = 2}, - [229] = {.lex_state = 41, .external_lex_state = 2}, + [227] = {.lex_state = 43}, + [228] = {.lex_state = 43}, + [229] = {.lex_state = 43}, [230] = {.lex_state = 41, .external_lex_state = 2}, [231] = {.lex_state = 41, .external_lex_state = 2}, [232] = {.lex_state = 41, .external_lex_state = 2}, @@ -5769,7 +5815,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [244] = {.lex_state = 41, .external_lex_state = 2}, [245] = {.lex_state = 41, .external_lex_state = 2}, [246] = {.lex_state = 41, .external_lex_state = 2}, - [247] = {.lex_state = 6, .external_lex_state = 2}, + [247] = {.lex_state = 41, .external_lex_state = 2}, [248] = {.lex_state = 41, .external_lex_state = 2}, [249] = {.lex_state = 41, .external_lex_state = 2}, [250] = {.lex_state = 41, .external_lex_state = 2}, @@ -5812,11 +5858,11 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [287] = {.lex_state = 41, .external_lex_state = 2}, [288] = {.lex_state = 41, .external_lex_state = 2}, [289] = {.lex_state = 41, .external_lex_state = 2}, - [290] = {.lex_state = 6, .external_lex_state = 2}, - [291] = {.lex_state = 6, .external_lex_state = 2}, + [290] = {.lex_state = 41, .external_lex_state = 2}, + [291] = {.lex_state = 41, .external_lex_state = 2}, [292] = {.lex_state = 6, .external_lex_state = 2}, - [293] = {.lex_state = 6, .external_lex_state = 2}, - [294] = {.lex_state = 6, .external_lex_state = 2}, + [293] = {.lex_state = 41, .external_lex_state = 2}, + [294] = {.lex_state = 41, .external_lex_state = 2}, [295] = {.lex_state = 6, .external_lex_state = 2}, [296] = {.lex_state = 6, .external_lex_state = 2}, [297] = {.lex_state = 6, .external_lex_state = 2}, @@ -5909,316 +5955,316 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [384] = {.lex_state = 6, .external_lex_state = 2}, [385] = {.lex_state = 6, .external_lex_state = 2}, [386] = {.lex_state = 6, .external_lex_state = 2}, - [387] = {.lex_state = 41, .external_lex_state = 2}, - [388] = {.lex_state = 41, .external_lex_state = 2}, - [389] = {.lex_state = 43}, - [390] = {.lex_state = 43}, - [391] = {.lex_state = 43}, - [392] = {.lex_state = 0}, - [393] = {.lex_state = 0}, - [394] = {.lex_state = 0}, - [395] = {.lex_state = 0}, - [396] = {.lex_state = 0}, - [397] = {.lex_state = 0}, - [398] = {.lex_state = 0}, - [399] = {.lex_state = 0}, + [387] = {.lex_state = 6, .external_lex_state = 2}, + [388] = {.lex_state = 6, .external_lex_state = 2}, + [389] = {.lex_state = 6, .external_lex_state = 2}, + [390] = {.lex_state = 6, .external_lex_state = 2}, + [391] = {.lex_state = 6, .external_lex_state = 2}, + [392] = {.lex_state = 6, .external_lex_state = 2}, + [393] = {.lex_state = 6, .external_lex_state = 2}, + [394] = {.lex_state = 41, .external_lex_state = 2}, + [395] = {.lex_state = 41, .external_lex_state = 2}, + [396] = {.lex_state = 43}, + [397] = {.lex_state = 43}, + [398] = {.lex_state = 43}, + [399] = {.lex_state = 41, .external_lex_state = 1}, [400] = {.lex_state = 0}, [401] = {.lex_state = 0}, [402] = {.lex_state = 0}, - [403] = {.lex_state = 0}, + [403] = {.lex_state = 41, .external_lex_state = 1}, [404] = {.lex_state = 0}, [405] = {.lex_state = 0}, [406] = {.lex_state = 0}, [407] = {.lex_state = 0}, [408] = {.lex_state = 0}, - [409] = {.lex_state = 0}, - [410] = {.lex_state = 0}, + [409] = {.lex_state = 41, .external_lex_state = 2}, + [410] = {.lex_state = 41, .external_lex_state = 1}, [411] = {.lex_state = 0}, [412] = {.lex_state = 0}, [413] = {.lex_state = 0}, - [414] = {.lex_state = 0}, + [414] = {.lex_state = 41, .external_lex_state = 2}, [415] = {.lex_state = 0}, [416] = {.lex_state = 0}, [417] = {.lex_state = 0}, [418] = {.lex_state = 0}, - [419] = {.lex_state = 41, .external_lex_state = 1}, + [419] = {.lex_state = 0}, [420] = {.lex_state = 0}, [421] = {.lex_state = 0}, [422] = {.lex_state = 0}, [423] = {.lex_state = 0}, [424] = {.lex_state = 0}, [425] = {.lex_state = 0}, - [426] = {.lex_state = 41, .external_lex_state = 1}, - [427] = {.lex_state = 41, .external_lex_state = 2}, - [428] = {.lex_state = 43}, - [429] = {.lex_state = 41, .external_lex_state = 1}, - [430] = {.lex_state = 41, .external_lex_state = 2}, - [431] = {.lex_state = 41, .external_lex_state = 1}, - [432] = {.lex_state = 41, .external_lex_state = 1}, - [433] = {.lex_state = 41, .external_lex_state = 1}, - [434] = {.lex_state = 41, .external_lex_state = 1}, - [435] = {.lex_state = 8}, - [436] = {.lex_state = 8}, - [437] = {.lex_state = 8}, - [438] = {.lex_state = 43}, - [439] = {.lex_state = 41, .external_lex_state = 1}, + [426] = {.lex_state = 0}, + [427] = {.lex_state = 0}, + [428] = {.lex_state = 0}, + [429] = {.lex_state = 0}, + [430] = {.lex_state = 0}, + [431] = {.lex_state = 0}, + [432] = {.lex_state = 0}, + [433] = {.lex_state = 0}, + [434] = {.lex_state = 0}, + [435] = {.lex_state = 0}, + [436] = {.lex_state = 0}, + [437] = {.lex_state = 41, .external_lex_state = 1}, + [438] = {.lex_state = 41, .external_lex_state = 1}, + [439] = {.lex_state = 43}, [440] = {.lex_state = 41, .external_lex_state = 1}, [441] = {.lex_state = 41, .external_lex_state = 1}, [442] = {.lex_state = 41, .external_lex_state = 1}, [443] = {.lex_state = 41, .external_lex_state = 1}, - [444] = {.lex_state = 41, .external_lex_state = 1}, + [444] = {.lex_state = 41, .external_lex_state = 2}, [445] = {.lex_state = 41, .external_lex_state = 1}, [446] = {.lex_state = 41, .external_lex_state = 1}, [447] = {.lex_state = 41, .external_lex_state = 1}, - [448] = {.lex_state = 41, .external_lex_state = 1}, + [448] = {.lex_state = 41, .external_lex_state = 2}, [449] = {.lex_state = 41, .external_lex_state = 1}, [450] = {.lex_state = 41, .external_lex_state = 1}, - [451] = {.lex_state = 41, .external_lex_state = 2}, + [451] = {.lex_state = 41, .external_lex_state = 1}, [452] = {.lex_state = 41, .external_lex_state = 1}, [453] = {.lex_state = 41, .external_lex_state = 1}, - [454] = {.lex_state = 8}, + [454] = {.lex_state = 41, .external_lex_state = 1}, [455] = {.lex_state = 41, .external_lex_state = 1}, [456] = {.lex_state = 41, .external_lex_state = 1}, - [457] = {.lex_state = 41, .external_lex_state = 1}, + [457] = {.lex_state = 41, .external_lex_state = 2}, [458] = {.lex_state = 41, .external_lex_state = 1}, [459] = {.lex_state = 41, .external_lex_state = 1}, [460] = {.lex_state = 41, .external_lex_state = 1}, - [461] = {.lex_state = 8}, + [461] = {.lex_state = 41, .external_lex_state = 1}, [462] = {.lex_state = 41, .external_lex_state = 1}, [463] = {.lex_state = 41, .external_lex_state = 1}, - [464] = {.lex_state = 41, .external_lex_state = 1}, + [464] = {.lex_state = 41, .external_lex_state = 2}, [465] = {.lex_state = 41, .external_lex_state = 1}, - [466] = {.lex_state = 0}, - [467] = {.lex_state = 41, .external_lex_state = 1}, + [466] = {.lex_state = 41, .external_lex_state = 1}, + [467] = {.lex_state = 41, .external_lex_state = 2}, [468] = {.lex_state = 41, .external_lex_state = 1}, - [469] = {.lex_state = 41, .external_lex_state = 2}, + [469] = {.lex_state = 41, .external_lex_state = 1}, [470] = {.lex_state = 41, .external_lex_state = 1}, [471] = {.lex_state = 41, .external_lex_state = 1}, - [472] = {.lex_state = 41, .external_lex_state = 1}, + [472] = {.lex_state = 41, .external_lex_state = 2}, [473] = {.lex_state = 41, .external_lex_state = 1}, [474] = {.lex_state = 41, .external_lex_state = 1}, - [475] = {.lex_state = 41, .external_lex_state = 2}, + [475] = {.lex_state = 41, .external_lex_state = 1}, [476] = {.lex_state = 41, .external_lex_state = 1}, [477] = {.lex_state = 41, .external_lex_state = 1}, [478] = {.lex_state = 41, .external_lex_state = 1}, [479] = {.lex_state = 41, .external_lex_state = 1}, [480] = {.lex_state = 41, .external_lex_state = 1}, - [481] = {.lex_state = 8}, + [481] = {.lex_state = 41, .external_lex_state = 1}, [482] = {.lex_state = 41, .external_lex_state = 1}, - [483] = {.lex_state = 0}, + [483] = {.lex_state = 41, .external_lex_state = 1}, [484] = {.lex_state = 41, .external_lex_state = 1}, [485] = {.lex_state = 41, .external_lex_state = 1}, [486] = {.lex_state = 41, .external_lex_state = 1}, [487] = {.lex_state = 41, .external_lex_state = 1}, [488] = {.lex_state = 41, .external_lex_state = 1}, [489] = {.lex_state = 41, .external_lex_state = 1}, - [490] = {.lex_state = 41, .external_lex_state = 1}, + [490] = {.lex_state = 8}, [491] = {.lex_state = 41, .external_lex_state = 1}, [492] = {.lex_state = 41, .external_lex_state = 1}, [493] = {.lex_state = 41, .external_lex_state = 1}, [494] = {.lex_state = 41, .external_lex_state = 1}, [495] = {.lex_state = 41, .external_lex_state = 1}, - [496] = {.lex_state = 41, .external_lex_state = 1}, - [497] = {.lex_state = 8}, - [498] = {.lex_state = 41, .external_lex_state = 1}, + [496] = {.lex_state = 41, .external_lex_state = 2}, + [497] = {.lex_state = 41, .external_lex_state = 1}, + [498] = {.lex_state = 41, .external_lex_state = 2}, [499] = {.lex_state = 41, .external_lex_state = 1}, [500] = {.lex_state = 41, .external_lex_state = 1}, [501] = {.lex_state = 41, .external_lex_state = 1}, - [502] = {.lex_state = 41, .external_lex_state = 1}, - [503] = {.lex_state = 41, .external_lex_state = 2}, - [504] = {.lex_state = 8}, + [502] = {.lex_state = 41, .external_lex_state = 2}, + [503] = {.lex_state = 43}, + [504] = {.lex_state = 41, .external_lex_state = 1}, [505] = {.lex_state = 8}, - [506] = {.lex_state = 41, .external_lex_state = 1}, + [506] = {.lex_state = 41, .external_lex_state = 2}, [507] = {.lex_state = 41, .external_lex_state = 1}, [508] = {.lex_state = 41, .external_lex_state = 1}, - [509] = {.lex_state = 41, .external_lex_state = 2}, - [510] = {.lex_state = 8}, - [511] = {.lex_state = 8}, - [512] = {.lex_state = 41, .external_lex_state = 1}, + [509] = {.lex_state = 41, .external_lex_state = 1}, + [510] = {.lex_state = 41, .external_lex_state = 1}, + [511] = {.lex_state = 41, .external_lex_state = 1}, + [512] = {.lex_state = 41, .external_lex_state = 2}, [513] = {.lex_state = 41, .external_lex_state = 1}, - [514] = {.lex_state = 41, .external_lex_state = 2}, - [515] = {.lex_state = 0}, - [516] = {.lex_state = 41, .external_lex_state = 2}, - [517] = {.lex_state = 41, .external_lex_state = 2}, - [518] = {.lex_state = 43}, - [519] = {.lex_state = 41, .external_lex_state = 2}, - [520] = {.lex_state = 41, .external_lex_state = 2}, - [521] = {.lex_state = 41, .external_lex_state = 2}, + [514] = {.lex_state = 41, .external_lex_state = 1}, + [515] = {.lex_state = 41, .external_lex_state = 1}, + [516] = {.lex_state = 41, .external_lex_state = 1}, + [517] = {.lex_state = 41, .external_lex_state = 1}, + [518] = {.lex_state = 41, .external_lex_state = 2}, + [519] = {.lex_state = 41, .external_lex_state = 1}, + [520] = {.lex_state = 8}, + [521] = {.lex_state = 41, .external_lex_state = 1}, [522] = {.lex_state = 41, .external_lex_state = 1}, [523] = {.lex_state = 41, .external_lex_state = 1}, - [524] = {.lex_state = 8}, - [525] = {.lex_state = 41, .external_lex_state = 2}, - [526] = {.lex_state = 8}, + [524] = {.lex_state = 41, .external_lex_state = 1}, + [525] = {.lex_state = 41, .external_lex_state = 1}, + [526] = {.lex_state = 41, .external_lex_state = 1}, [527] = {.lex_state = 41, .external_lex_state = 1}, [528] = {.lex_state = 41, .external_lex_state = 1}, - [529] = {.lex_state = 41, .external_lex_state = 2}, - [530] = {.lex_state = 41, .external_lex_state = 1}, - [531] = {.lex_state = 0}, - [532] = {.lex_state = 0}, - [533] = {.lex_state = 0}, + [529] = {.lex_state = 41, .external_lex_state = 1}, + [530] = {.lex_state = 41, .external_lex_state = 2}, + [531] = {.lex_state = 41, .external_lex_state = 1}, + [532] = {.lex_state = 41, .external_lex_state = 1}, + [533] = {.lex_state = 41, .external_lex_state = 1}, [534] = {.lex_state = 41, .external_lex_state = 1}, [535] = {.lex_state = 41, .external_lex_state = 1}, - [536] = {.lex_state = 8}, - [537] = {.lex_state = 0}, - [538] = {.lex_state = 41, .external_lex_state = 2}, - [539] = {.lex_state = 41, .external_lex_state = 1}, - [540] = {.lex_state = 41, .external_lex_state = 1}, - [541] = {.lex_state = 41, .external_lex_state = 2}, - [542] = {.lex_state = 41, .external_lex_state = 1}, - [543] = {.lex_state = 41, .external_lex_state = 1}, - [544] = {.lex_state = 41, .external_lex_state = 1}, + [536] = {.lex_state = 41, .external_lex_state = 1}, + [537] = {.lex_state = 41, .external_lex_state = 1}, + [538] = {.lex_state = 8}, + [539] = {.lex_state = 41, .external_lex_state = 2}, + [540] = {.lex_state = 8}, + [541] = {.lex_state = 41, .external_lex_state = 1}, + [542] = {.lex_state = 41, .external_lex_state = 2}, + [543] = {.lex_state = 8}, + [544] = {.lex_state = 41, .external_lex_state = 2}, [545] = {.lex_state = 41, .external_lex_state = 2}, - [546] = {.lex_state = 8}, - [547] = {.lex_state = 41, .external_lex_state = 2}, - [548] = {.lex_state = 41, .external_lex_state = 1}, - [549] = {.lex_state = 41, .external_lex_state = 1}, + [546] = {.lex_state = 41, .external_lex_state = 2}, + [547] = {.lex_state = 0}, + [548] = {.lex_state = 41, .external_lex_state = 2}, + [549] = {.lex_state = 41, .external_lex_state = 2}, [550] = {.lex_state = 41, .external_lex_state = 1}, - [551] = {.lex_state = 41, .external_lex_state = 1}, + [551] = {.lex_state = 8}, [552] = {.lex_state = 41, .external_lex_state = 1}, - [553] = {.lex_state = 41, .external_lex_state = 1}, + [553] = {.lex_state = 41, .external_lex_state = 2}, [554] = {.lex_state = 41, .external_lex_state = 1}, [555] = {.lex_state = 41, .external_lex_state = 1}, - [556] = {.lex_state = 41, .external_lex_state = 1}, + [556] = {.lex_state = 41, .external_lex_state = 2}, [557] = {.lex_state = 41, .external_lex_state = 1}, [558] = {.lex_state = 41, .external_lex_state = 2}, [559] = {.lex_state = 41, .external_lex_state = 1}, - [560] = {.lex_state = 8}, - [561] = {.lex_state = 9}, - [562] = {.lex_state = 41, .external_lex_state = 1}, - [563] = {.lex_state = 41, .external_lex_state = 1}, - [564] = {.lex_state = 41, .external_lex_state = 2}, + [560] = {.lex_state = 41, .external_lex_state = 2}, + [561] = {.lex_state = 41, .external_lex_state = 2}, + [562] = {.lex_state = 41, .external_lex_state = 2}, + [563] = {.lex_state = 41, .external_lex_state = 2}, + [564] = {.lex_state = 41, .external_lex_state = 1}, [565] = {.lex_state = 41, .external_lex_state = 1}, - [566] = {.lex_state = 41, .external_lex_state = 1}, - [567] = {.lex_state = 8}, - [568] = {.lex_state = 41, .external_lex_state = 1}, + [566] = {.lex_state = 41, .external_lex_state = 2}, + [567] = {.lex_state = 41, .external_lex_state = 1}, + [568] = {.lex_state = 41, .external_lex_state = 2}, [569] = {.lex_state = 41, .external_lex_state = 1}, - [570] = {.lex_state = 41, .external_lex_state = 2}, - [571] = {.lex_state = 41, .external_lex_state = 1}, - [572] = {.lex_state = 41, .external_lex_state = 1}, - [573] = {.lex_state = 41, .external_lex_state = 1}, - [574] = {.lex_state = 41, .external_lex_state = 1}, + [570] = {.lex_state = 41, .external_lex_state = 1}, + [571] = {.lex_state = 41, .external_lex_state = 2}, + [572] = {.lex_state = 8}, + [573] = {.lex_state = 41, .external_lex_state = 2}, + [574] = {.lex_state = 41, .external_lex_state = 2}, [575] = {.lex_state = 41, .external_lex_state = 2}, [576] = {.lex_state = 41, .external_lex_state = 2}, [577] = {.lex_state = 41, .external_lex_state = 2}, [578] = {.lex_state = 41, .external_lex_state = 2}, - [579] = {.lex_state = 41, .external_lex_state = 2}, - [580] = {.lex_state = 41, .external_lex_state = 2}, + [579] = {.lex_state = 41, .external_lex_state = 1}, + [580] = {.lex_state = 8}, [581] = {.lex_state = 41, .external_lex_state = 2}, - [582] = {.lex_state = 41, .external_lex_state = 1}, - [583] = {.lex_state = 41, .external_lex_state = 1}, + [582] = {.lex_state = 8}, + [583] = {.lex_state = 41, .external_lex_state = 2}, [584] = {.lex_state = 41, .external_lex_state = 2}, [585] = {.lex_state = 41, .external_lex_state = 2}, - [586] = {.lex_state = 41, .external_lex_state = 2}, - [587] = {.lex_state = 41, .external_lex_state = 2}, + [586] = {.lex_state = 41, .external_lex_state = 1}, + [587] = {.lex_state = 41, .external_lex_state = 1}, [588] = {.lex_state = 41, .external_lex_state = 1}, [589] = {.lex_state = 41, .external_lex_state = 2}, - [590] = {.lex_state = 41, .external_lex_state = 1}, + [590] = {.lex_state = 41, .external_lex_state = 2}, [591] = {.lex_state = 41, .external_lex_state = 1}, - [592] = {.lex_state = 41, .external_lex_state = 2}, + [592] = {.lex_state = 41, .external_lex_state = 1}, [593] = {.lex_state = 41, .external_lex_state = 1}, - [594] = {.lex_state = 41, .external_lex_state = 2}, - [595] = {.lex_state = 41, .external_lex_state = 2}, - [596] = {.lex_state = 41, .external_lex_state = 2}, - [597] = {.lex_state = 41, .external_lex_state = 2}, - [598] = {.lex_state = 41, .external_lex_state = 2}, - [599] = {.lex_state = 41, .external_lex_state = 1}, - [600] = {.lex_state = 41, .external_lex_state = 2}, - [601] = {.lex_state = 41, .external_lex_state = 2}, + [594] = {.lex_state = 8}, + [595] = {.lex_state = 41, .external_lex_state = 1}, + [596] = {.lex_state = 41, .external_lex_state = 1}, + [597] = {.lex_state = 41, .external_lex_state = 1}, + [598] = {.lex_state = 41, .external_lex_state = 1}, + [599] = {.lex_state = 41, .external_lex_state = 2}, + [600] = {.lex_state = 41, .external_lex_state = 1}, + [601] = {.lex_state = 41, .external_lex_state = 1}, [602] = {.lex_state = 41, .external_lex_state = 2}, [603] = {.lex_state = 41, .external_lex_state = 2}, - [604] = {.lex_state = 41, .external_lex_state = 1}, - [605] = {.lex_state = 41, .external_lex_state = 1}, - [606] = {.lex_state = 41, .external_lex_state = 1}, + [604] = {.lex_state = 0}, + [605] = {.lex_state = 41, .external_lex_state = 2}, + [606] = {.lex_state = 41, .external_lex_state = 2}, [607] = {.lex_state = 41, .external_lex_state = 1}, [608] = {.lex_state = 41, .external_lex_state = 1}, - [609] = {.lex_state = 41, .external_lex_state = 2}, - [610] = {.lex_state = 41, .external_lex_state = 2}, - [611] = {.lex_state = 41, .external_lex_state = 1}, + [609] = {.lex_state = 41, .external_lex_state = 1}, + [610] = {.lex_state = 41, .external_lex_state = 1}, + [611] = {.lex_state = 0}, [612] = {.lex_state = 41, .external_lex_state = 2}, - [613] = {.lex_state = 41, .external_lex_state = 2}, + [613] = {.lex_state = 8}, [614] = {.lex_state = 41, .external_lex_state = 2}, - [615] = {.lex_state = 9}, + [615] = {.lex_state = 41, .external_lex_state = 2}, [616] = {.lex_state = 8}, - [617] = {.lex_state = 43}, - [618] = {.lex_state = 43}, + [617] = {.lex_state = 0}, + [618] = {.lex_state = 41, .external_lex_state = 2}, [619] = {.lex_state = 8}, [620] = {.lex_state = 41, .external_lex_state = 2}, - [621] = {.lex_state = 41, .external_lex_state = 2}, - [622] = {.lex_state = 41, .external_lex_state = 2}, - [623] = {.lex_state = 41, .external_lex_state = 2}, + [621] = {.lex_state = 43}, + [622] = {.lex_state = 0}, + [623] = {.lex_state = 0}, [624] = {.lex_state = 41, .external_lex_state = 2}, - [625] = {.lex_state = 8}, + [625] = {.lex_state = 0}, [626] = {.lex_state = 41, .external_lex_state = 2}, - [627] = {.lex_state = 41, .external_lex_state = 2}, - [628] = {.lex_state = 9}, - [629] = {.lex_state = 0}, - [630] = {.lex_state = 0}, - [631] = {.lex_state = 0}, - [632] = {.lex_state = 0}, - [633] = {.lex_state = 0}, - [634] = {.lex_state = 0}, + [627] = {.lex_state = 8}, + [628] = {.lex_state = 8}, + [629] = {.lex_state = 8}, + [630] = {.lex_state = 8}, + [631] = {.lex_state = 8}, + [632] = {.lex_state = 8}, + [633] = {.lex_state = 43}, + [634] = {.lex_state = 43}, [635] = {.lex_state = 0}, [636] = {.lex_state = 0}, [637] = {.lex_state = 0}, - [638] = {.lex_state = 43}, - [639] = {.lex_state = 43}, - [640] = {.lex_state = 43}, - [641] = {.lex_state = 43}, - [642] = {.lex_state = 43}, + [638] = {.lex_state = 0}, + [639] = {.lex_state = 0}, + [640] = {.lex_state = 0}, + [641] = {.lex_state = 0}, + [642] = {.lex_state = 0}, [643] = {.lex_state = 0}, [644] = {.lex_state = 43}, - [645] = {.lex_state = 0}, + [645] = {.lex_state = 43}, [646] = {.lex_state = 43}, - [647] = {.lex_state = 0}, - [648] = {.lex_state = 0}, - [649] = {.lex_state = 8}, + [647] = {.lex_state = 43}, + [648] = {.lex_state = 43}, + [649] = {.lex_state = 43}, [650] = {.lex_state = 0}, [651] = {.lex_state = 0}, - [652] = {.lex_state = 41}, - [653] = {.lex_state = 0}, - [654] = {.lex_state = 41}, - [655] = {.lex_state = 0}, - [656] = {.lex_state = 10}, - [657] = {.lex_state = 10}, + [652] = {.lex_state = 0}, + [653] = {.lex_state = 8}, + [654] = {.lex_state = 8}, + [655] = {.lex_state = 43}, + [656] = {.lex_state = 0}, + [657] = {.lex_state = 8}, [658] = {.lex_state = 0}, - [659] = {.lex_state = 10}, + [659] = {.lex_state = 41}, [660] = {.lex_state = 0}, - [661] = {.lex_state = 41}, - [662] = {.lex_state = 0}, - [663] = {.lex_state = 41}, - [664] = {.lex_state = 10}, + [661] = {.lex_state = 0}, + [662] = {.lex_state = 41}, + [663] = {.lex_state = 10}, + [664] = {.lex_state = 0}, [665] = {.lex_state = 0}, - [666] = {.lex_state = 41}, - [667] = {.lex_state = 41}, + [666] = {.lex_state = 0}, + [667] = {.lex_state = 10}, [668] = {.lex_state = 0}, - [669] = {.lex_state = 0}, + [669] = {.lex_state = 41}, [670] = {.lex_state = 0}, - [671] = {.lex_state = 0}, + [671] = {.lex_state = 10}, [672] = {.lex_state = 0}, - [673] = {.lex_state = 41}, - [674] = {.lex_state = 0}, - [675] = {.lex_state = 0}, + [673] = {.lex_state = 0}, + [674] = {.lex_state = 10}, + [675] = {.lex_state = 41}, [676] = {.lex_state = 0}, [677] = {.lex_state = 0}, [678] = {.lex_state = 0}, - [679] = {.lex_state = 41}, + [679] = {.lex_state = 0}, [680] = {.lex_state = 0}, - [681] = {.lex_state = 0}, + [681] = {.lex_state = 41}, [682] = {.lex_state = 0}, [683] = {.lex_state = 0}, [684] = {.lex_state = 0}, - [685] = {.lex_state = 0}, - [686] = {.lex_state = 0}, - [687] = {.lex_state = 0}, - [688] = {.lex_state = 0}, + [685] = {.lex_state = 8}, + [686] = {.lex_state = 41}, + [687] = {.lex_state = 41}, + [688] = {.lex_state = 41}, [689] = {.lex_state = 0}, [690] = {.lex_state = 0}, - [691] = {.lex_state = 0}, + [691] = {.lex_state = 8}, [692] = {.lex_state = 0}, [693] = {.lex_state = 0}, [694] = {.lex_state = 0}, [695] = {.lex_state = 0}, - [696] = {.lex_state = 8}, + [696] = {.lex_state = 0}, [697] = {.lex_state = 0}, [698] = {.lex_state = 0}, [699] = {.lex_state = 0}, @@ -6274,7 +6320,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [749] = {.lex_state = 0}, [750] = {.lex_state = 0}, [751] = {.lex_state = 0}, - [752] = {.lex_state = 10}, + [752] = {.lex_state = 0}, [753] = {.lex_state = 0}, [754] = {.lex_state = 0}, [755] = {.lex_state = 0}, @@ -6283,18 +6329,18 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [758] = {.lex_state = 0}, [759] = {.lex_state = 0}, [760] = {.lex_state = 0}, - [761] = {.lex_state = 0}, + [761] = {.lex_state = 41}, [762] = {.lex_state = 0}, [763] = {.lex_state = 0}, [764] = {.lex_state = 0}, - [765] = {.lex_state = 0}, + [765] = {.lex_state = 10}, [766] = {.lex_state = 0}, [767] = {.lex_state = 0}, [768] = {.lex_state = 0}, [769] = {.lex_state = 0}, [770] = {.lex_state = 0}, [771] = {.lex_state = 0}, - [772] = {.lex_state = 10}, + [772] = {.lex_state = 0}, [773] = {.lex_state = 0}, [774] = {.lex_state = 0}, [775] = {.lex_state = 0}, @@ -6303,44 +6349,44 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [778] = {.lex_state = 0}, [779] = {.lex_state = 0}, [780] = {.lex_state = 0}, - [781] = {.lex_state = 10}, + [781] = {.lex_state = 0}, [782] = {.lex_state = 0}, [783] = {.lex_state = 0}, [784] = {.lex_state = 0}, [785] = {.lex_state = 0}, [786] = {.lex_state = 0}, [787] = {.lex_state = 0}, - [788] = {.lex_state = 10}, - [789] = {.lex_state = 0}, - [790] = {.lex_state = 8}, - [791] = {.lex_state = 43}, + [788] = {.lex_state = 0}, + [789] = {.lex_state = 10}, + [790] = {.lex_state = 0}, + [791] = {.lex_state = 0}, [792] = {.lex_state = 0}, - [793] = {.lex_state = 8}, + [793] = {.lex_state = 0}, [794] = {.lex_state = 0}, - [795] = {.lex_state = 41}, - [796] = {.lex_state = 8}, + [795] = {.lex_state = 0}, + [796] = {.lex_state = 0}, [797] = {.lex_state = 0}, [798] = {.lex_state = 0}, - [799] = {.lex_state = 41}, - [800] = {.lex_state = 8}, - [801] = {.lex_state = 41}, - [802] = {.lex_state = 41}, - [803] = {.lex_state = 41}, - [804] = {.lex_state = 41}, + [799] = {.lex_state = 10}, + [800] = {.lex_state = 0}, + [801] = {.lex_state = 10}, + [802] = {.lex_state = 0}, + [803] = {.lex_state = 8}, + [804] = {.lex_state = 8}, [805] = {.lex_state = 43}, - [806] = {.lex_state = 8}, - [807] = {.lex_state = 41}, - [808] = {.lex_state = 0}, - [809] = {.lex_state = 41}, - [810] = {.lex_state = 21}, + [806] = {.lex_state = 43}, + [807] = {.lex_state = 8}, + [808] = {.lex_state = 8}, + [809] = {.lex_state = 8}, + [810] = {.lex_state = 0}, [811] = {.lex_state = 41}, - [812] = {.lex_state = 43}, - [813] = {.lex_state = 21}, - [814] = {.lex_state = 43}, + [812] = {.lex_state = 0}, + [813] = {.lex_state = 0}, + [814] = {.lex_state = 41}, [815] = {.lex_state = 41}, [816] = {.lex_state = 41}, [817] = {.lex_state = 41}, - [818] = {.lex_state = 41}, + [818] = {.lex_state = 0}, [819] = {.lex_state = 41}, [820] = {.lex_state = 41}, [821] = {.lex_state = 41}, @@ -6348,39 +6394,39 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [823] = {.lex_state = 41}, [824] = {.lex_state = 41}, [825] = {.lex_state = 41}, - [826] = {.lex_state = 0}, - [827] = {.lex_state = 0}, + [826] = {.lex_state = 41}, + [827] = {.lex_state = 16}, [828] = {.lex_state = 41}, - [829] = {.lex_state = 41}, + [829] = {.lex_state = 16}, [830] = {.lex_state = 41}, [831] = {.lex_state = 41}, - [832] = {.lex_state = 0}, - [833] = {.lex_state = 41}, + [832] = {.lex_state = 41}, + [833] = {.lex_state = 0}, [834] = {.lex_state = 41}, - [835] = {.lex_state = 0}, + [835] = {.lex_state = 43}, [836] = {.lex_state = 41}, [837] = {.lex_state = 41}, - [838] = {.lex_state = 41}, + [838] = {.lex_state = 43}, [839] = {.lex_state = 41}, [840] = {.lex_state = 41}, [841] = {.lex_state = 41}, - [842] = {.lex_state = 41}, - [843] = {.lex_state = 41}, + [842] = {.lex_state = 0}, + [843] = {.lex_state = 0}, [844] = {.lex_state = 41}, - [845] = {.lex_state = 41}, + [845] = {.lex_state = 8, .external_lex_state = 3}, [846] = {.lex_state = 41}, - [847] = {.lex_state = 8, .external_lex_state = 3}, + [847] = {.lex_state = 41}, [848] = {.lex_state = 41}, - [849] = {.lex_state = 8, .external_lex_state = 3}, + [849] = {.lex_state = 41}, [850] = {.lex_state = 41}, - [851] = {.lex_state = 0}, - [852] = {.lex_state = 0}, - [853] = {.lex_state = 0}, - [854] = {.lex_state = 8, .external_lex_state = 3}, + [851] = {.lex_state = 41}, + [852] = {.lex_state = 41}, + [853] = {.lex_state = 41}, + [854] = {.lex_state = 41}, [855] = {.lex_state = 41}, - [856] = {.lex_state = 0}, - [857] = {.lex_state = 0}, - [858] = {.lex_state = 41}, + [856] = {.lex_state = 41}, + [857] = {.lex_state = 41}, + [858] = {.lex_state = 0}, [859] = {.lex_state = 0}, [860] = {.lex_state = 41}, [861] = {.lex_state = 41}, @@ -6388,8 +6434,8 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [863] = {.lex_state = 41}, [864] = {.lex_state = 41}, [865] = {.lex_state = 41}, - [866] = {.lex_state = 0}, - [867] = {.lex_state = 0}, + [866] = {.lex_state = 8, .external_lex_state = 3}, + [867] = {.lex_state = 8, .external_lex_state = 3}, [868] = {.lex_state = 41}, [869] = {.lex_state = 41}, [870] = {.lex_state = 41}, @@ -6397,35 +6443,35 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [872] = {.lex_state = 41}, [873] = {.lex_state = 41}, [874] = {.lex_state = 41}, - [875] = {.lex_state = 0}, - [876] = {.lex_state = 0}, + [875] = {.lex_state = 41}, + [876] = {.lex_state = 41}, [877] = {.lex_state = 41}, [878] = {.lex_state = 41}, - [879] = {.lex_state = 41}, - [880] = {.lex_state = 41}, - [881] = {.lex_state = 41}, - [882] = {.lex_state = 41}, + [879] = {.lex_state = 0}, + [880] = {.lex_state = 0}, + [881] = {.lex_state = 0}, + [882] = {.lex_state = 0}, [883] = {.lex_state = 41}, [884] = {.lex_state = 41}, [885] = {.lex_state = 41}, [886] = {.lex_state = 41}, - [887] = {.lex_state = 0}, + [887] = {.lex_state = 41}, [888] = {.lex_state = 41}, - [889] = {.lex_state = 0}, + [889] = {.lex_state = 41}, [890] = {.lex_state = 41}, [891] = {.lex_state = 0}, [892] = {.lex_state = 41}, [893] = {.lex_state = 41}, - [894] = {.lex_state = 41}, - [895] = {.lex_state = 41}, + [894] = {.lex_state = 0}, + [895] = {.lex_state = 0}, [896] = {.lex_state = 41}, [897] = {.lex_state = 41}, - [898] = {.lex_state = 41}, + [898] = {.lex_state = 0}, [899] = {.lex_state = 41}, [900] = {.lex_state = 41}, [901] = {.lex_state = 41}, [902] = {.lex_state = 41}, - [903] = {.lex_state = 41}, + [903] = {.lex_state = 0}, [904] = {.lex_state = 41}, [905] = {.lex_state = 41}, [906] = {.lex_state = 41}, @@ -6439,82 +6485,82 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [914] = {.lex_state = 41}, [915] = {.lex_state = 41}, [916] = {.lex_state = 41}, - [917] = {.lex_state = 0}, + [917] = {.lex_state = 41}, [918] = {.lex_state = 41}, [919] = {.lex_state = 41}, - [920] = {.lex_state = 0}, + [920] = {.lex_state = 41}, [921] = {.lex_state = 41}, - [922] = {.lex_state = 8, .external_lex_state = 3}, + [922] = {.lex_state = 0}, [923] = {.lex_state = 0}, - [924] = {.lex_state = 0}, - [925] = {.lex_state = 0}, - [926] = {.lex_state = 0}, + [924] = {.lex_state = 41}, + [925] = {.lex_state = 41}, + [926] = {.lex_state = 41}, [927] = {.lex_state = 41}, - [928] = {.lex_state = 0}, + [928] = {.lex_state = 41}, [929] = {.lex_state = 41}, - [930] = {.lex_state = 41}, - [931] = {.lex_state = 0}, - [932] = {.lex_state = 41}, - [933] = {.lex_state = 0}, - [934] = {.lex_state = 41}, - [935] = {.lex_state = 8, .external_lex_state = 3}, - [936] = {.lex_state = 8, .external_lex_state = 3}, + [930] = {.lex_state = 0}, + [931] = {.lex_state = 41}, + [932] = {.lex_state = 0}, + [933] = {.lex_state = 41}, + [934] = {.lex_state = 0}, + [935] = {.lex_state = 0}, + [936] = {.lex_state = 41}, [937] = {.lex_state = 41}, - [938] = {.lex_state = 41}, + [938] = {.lex_state = 8, .external_lex_state = 3}, [939] = {.lex_state = 0}, [940] = {.lex_state = 0}, - [941] = {.lex_state = 41}, + [941] = {.lex_state = 0}, [942] = {.lex_state = 0}, [943] = {.lex_state = 0}, [944] = {.lex_state = 0}, [945] = {.lex_state = 0}, [946] = {.lex_state = 0}, [947] = {.lex_state = 41}, - [948] = {.lex_state = 41}, + [948] = {.lex_state = 0}, [949] = {.lex_state = 41}, [950] = {.lex_state = 0}, - [951] = {.lex_state = 0}, + [951] = {.lex_state = 41}, [952] = {.lex_state = 41}, - [953] = {.lex_state = 11}, - [954] = {.lex_state = 11}, + [953] = {.lex_state = 0}, + [954] = {.lex_state = 8, .external_lex_state = 3}, [955] = {.lex_state = 8, .external_lex_state = 3}, - [956] = {.lex_state = 11}, - [957] = {.lex_state = 11}, - [958] = {.lex_state = 11}, - [959] = {.lex_state = 11}, - [960] = {.lex_state = 11}, - [961] = {.lex_state = 11}, + [956] = {.lex_state = 41}, + [957] = {.lex_state = 0}, + [958] = {.lex_state = 41}, + [959] = {.lex_state = 41}, + [960] = {.lex_state = 41}, + [961] = {.lex_state = 41}, [962] = {.lex_state = 41}, - [963] = {.lex_state = 41}, - [964] = {.lex_state = 11}, + [963] = {.lex_state = 0}, + [964] = {.lex_state = 0}, [965] = {.lex_state = 41}, - [966] = {.lex_state = 11}, + [966] = {.lex_state = 0}, [967] = {.lex_state = 41}, - [968] = {.lex_state = 11}, - [969] = {.lex_state = 11}, - [970] = {.lex_state = 11}, - [971] = {.lex_state = 11}, - [972] = {.lex_state = 11}, - [973] = {.lex_state = 11}, - [974] = {.lex_state = 41}, - [975] = {.lex_state = 41}, - [976] = {.lex_state = 41}, - [977] = {.lex_state = 41}, - [978] = {.lex_state = 41}, - [979] = {.lex_state = 41}, - [980] = {.lex_state = 41}, + [968] = {.lex_state = 0}, + [969] = {.lex_state = 41}, + [970] = {.lex_state = 9}, + [971] = {.lex_state = 41}, + [972] = {.lex_state = 41}, + [973] = {.lex_state = 9}, + [974] = {.lex_state = 9}, + [975] = {.lex_state = 9}, + [976] = {.lex_state = 9}, + [977] = {.lex_state = 9}, + [978] = {.lex_state = 9}, + [979] = {.lex_state = 9}, + [980] = {.lex_state = 8, .external_lex_state = 3}, [981] = {.lex_state = 9}, - [982] = {.lex_state = 41, .external_lex_state = 3}, - [983] = {.lex_state = 41}, - [984] = {.lex_state = 41}, - [985] = {.lex_state = 41}, + [982] = {.lex_state = 9}, + [983] = {.lex_state = 9}, + [984] = {.lex_state = 9}, + [985] = {.lex_state = 9}, [986] = {.lex_state = 41}, - [987] = {.lex_state = 41}, - [988] = {.lex_state = 41}, - [989] = {.lex_state = 41}, + [987] = {.lex_state = 9}, + [988] = {.lex_state = 9}, + [989] = {.lex_state = 9}, [990] = {.lex_state = 41}, [991] = {.lex_state = 41}, - [992] = {.lex_state = 8}, + [992] = {.lex_state = 41}, [993] = {.lex_state = 41}, [994] = {.lex_state = 41}, [995] = {.lex_state = 41}, @@ -6527,136 +6573,136 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1002] = {.lex_state = 41}, [1003] = {.lex_state = 41}, [1004] = {.lex_state = 41}, - [1005] = {.lex_state = 41}, + [1005] = {.lex_state = 8, .external_lex_state = 3}, [1006] = {.lex_state = 41}, [1007] = {.lex_state = 41}, [1008] = {.lex_state = 41}, [1009] = {.lex_state = 41}, - [1010] = {.lex_state = 8, .external_lex_state = 3}, + [1010] = {.lex_state = 41}, [1011] = {.lex_state = 41}, [1012] = {.lex_state = 41}, [1013] = {.lex_state = 41}, - [1014] = {.lex_state = 8}, + [1014] = {.lex_state = 41}, [1015] = {.lex_state = 41}, - [1016] = {.lex_state = 41}, + [1016] = {.lex_state = 16}, [1017] = {.lex_state = 41}, - [1018] = {.lex_state = 41}, - [1019] = {.lex_state = 0}, + [1018] = {.lex_state = 8}, + [1019] = {.lex_state = 41}, [1020] = {.lex_state = 41}, [1021] = {.lex_state = 41}, [1022] = {.lex_state = 41}, [1023] = {.lex_state = 41}, [1024] = {.lex_state = 41}, [1025] = {.lex_state = 41}, - [1026] = {.lex_state = 41}, + [1026] = {.lex_state = 8}, [1027] = {.lex_state = 41}, - [1028] = {.lex_state = 41}, + [1028] = {.lex_state = 0}, [1029] = {.lex_state = 41}, - [1030] = {.lex_state = 0}, - [1031] = {.lex_state = 41}, + [1030] = {.lex_state = 41}, + [1031] = {.lex_state = 41, .external_lex_state = 3}, [1032] = {.lex_state = 41}, - [1033] = {.lex_state = 41}, + [1033] = {.lex_state = 8}, [1034] = {.lex_state = 41}, [1035] = {.lex_state = 41}, [1036] = {.lex_state = 41}, [1037] = {.lex_state = 41}, - [1038] = {.lex_state = 8}, + [1038] = {.lex_state = 41}, [1039] = {.lex_state = 41}, [1040] = {.lex_state = 41}, - [1041] = {.lex_state = 41, .external_lex_state = 3}, - [1042] = {.lex_state = 41, .external_lex_state = 3}, - [1043] = {.lex_state = 21}, + [1041] = {.lex_state = 41}, + [1042] = {.lex_state = 41}, + [1043] = {.lex_state = 41}, [1044] = {.lex_state = 41}, - [1045] = {.lex_state = 8, .external_lex_state = 3}, + [1045] = {.lex_state = 41}, [1046] = {.lex_state = 41}, - [1047] = {.lex_state = 21}, + [1047] = {.lex_state = 41}, [1048] = {.lex_state = 41}, [1049] = {.lex_state = 41}, [1050] = {.lex_state = 41}, - [1051] = {.lex_state = 21}, - [1052] = {.lex_state = 21}, - [1053] = {.lex_state = 41, .external_lex_state = 3}, + [1051] = {.lex_state = 41}, + [1052] = {.lex_state = 41}, + [1053] = {.lex_state = 0}, [1054] = {.lex_state = 41}, [1055] = {.lex_state = 41}, - [1056] = {.lex_state = 41}, - [1057] = {.lex_state = 21}, + [1056] = {.lex_state = 8}, + [1057] = {.lex_state = 8, .external_lex_state = 3}, [1058] = {.lex_state = 8}, - [1059] = {.lex_state = 21}, - [1060] = {.lex_state = 41}, - [1061] = {.lex_state = 41}, + [1059] = {.lex_state = 16}, + [1060] = {.lex_state = 8, .external_lex_state = 3}, + [1061] = {.lex_state = 16}, [1062] = {.lex_state = 41}, - [1063] = {.lex_state = 8}, + [1063] = {.lex_state = 41}, [1064] = {.lex_state = 41}, - [1065] = {.lex_state = 8}, - [1066] = {.lex_state = 8}, - [1067] = {.lex_state = 21}, - [1068] = {.lex_state = 8, .external_lex_state = 3}, - [1069] = {.lex_state = 8}, - [1070] = {.lex_state = 41, .external_lex_state = 3}, - [1071] = {.lex_state = 21}, - [1072] = {.lex_state = 21}, + [1065] = {.lex_state = 41}, + [1066] = {.lex_state = 41, .external_lex_state = 3}, + [1067] = {.lex_state = 41}, + [1068] = {.lex_state = 41, .external_lex_state = 3}, + [1069] = {.lex_state = 16}, + [1070] = {.lex_state = 41}, + [1071] = {.lex_state = 41}, + [1072] = {.lex_state = 41}, [1073] = {.lex_state = 41}, - [1074] = {.lex_state = 8, .external_lex_state = 3}, - [1075] = {.lex_state = 41}, + [1074] = {.lex_state = 8}, + [1075] = {.lex_state = 41, .external_lex_state = 3}, [1076] = {.lex_state = 41}, [1077] = {.lex_state = 41}, - [1078] = {.lex_state = 41}, + [1078] = {.lex_state = 8}, [1079] = {.lex_state = 41}, [1080] = {.lex_state = 41}, - [1081] = {.lex_state = 21}, - [1082] = {.lex_state = 41}, - [1083] = {.lex_state = 21}, + [1081] = {.lex_state = 16}, + [1082] = {.lex_state = 16}, + [1083] = {.lex_state = 8}, [1084] = {.lex_state = 41}, - [1085] = {.lex_state = 21}, - [1086] = {.lex_state = 41}, - [1087] = {.lex_state = 8}, - [1088] = {.lex_state = 8}, - [1089] = {.lex_state = 41}, + [1085] = {.lex_state = 16}, + [1086] = {.lex_state = 16}, + [1087] = {.lex_state = 41}, + [1088] = {.lex_state = 41}, + [1089] = {.lex_state = 16}, [1090] = {.lex_state = 41}, - [1091] = {.lex_state = 21}, - [1092] = {.lex_state = 8}, - [1093] = {.lex_state = 41}, - [1094] = {.lex_state = 8}, - [1095] = {.lex_state = 41}, - [1096] = {.lex_state = 21}, - [1097] = {.lex_state = 21}, - [1098] = {.lex_state = 21}, - [1099] = {.lex_state = 21}, + [1091] = {.lex_state = 16}, + [1092] = {.lex_state = 41, .external_lex_state = 3}, + [1093] = {.lex_state = 16}, + [1094] = {.lex_state = 41}, + [1095] = {.lex_state = 16}, + [1096] = {.lex_state = 16}, + [1097] = {.lex_state = 41}, + [1098] = {.lex_state = 41}, + [1099] = {.lex_state = 16}, [1100] = {.lex_state = 41}, - [1101] = {.lex_state = 8, .external_lex_state = 3}, + [1101] = {.lex_state = 41}, [1102] = {.lex_state = 41}, - [1103] = {.lex_state = 41}, - [1104] = {.lex_state = 41}, - [1105] = {.lex_state = 41}, - [1106] = {.lex_state = 41}, + [1103] = {.lex_state = 16}, + [1104] = {.lex_state = 8}, + [1105] = {.lex_state = 8}, + [1106] = {.lex_state = 8, .external_lex_state = 3}, [1107] = {.lex_state = 41}, [1108] = {.lex_state = 41}, - [1109] = {.lex_state = 8}, + [1109] = {.lex_state = 8, .external_lex_state = 3}, [1110] = {.lex_state = 41}, - [1111] = {.lex_state = 41, .external_lex_state = 3}, - [1112] = {.lex_state = 41}, - [1113] = {.lex_state = 41}, + [1111] = {.lex_state = 41}, + [1112] = {.lex_state = 16}, + [1113] = {.lex_state = 8}, [1114] = {.lex_state = 41}, - [1115] = {.lex_state = 41}, - [1116] = {.lex_state = 41}, - [1117] = {.lex_state = 41}, + [1115] = {.lex_state = 16}, + [1116] = {.lex_state = 16}, + [1117] = {.lex_state = 8}, [1118] = {.lex_state = 41}, [1119] = {.lex_state = 41}, [1120] = {.lex_state = 41}, - [1121] = {.lex_state = 41}, - [1122] = {.lex_state = 41}, + [1121] = {.lex_state = 16}, + [1122] = {.lex_state = 41, .external_lex_state = 3}, [1123] = {.lex_state = 41}, - [1124] = {.lex_state = 41, .external_lex_state = 3}, - [1125] = {.lex_state = 41, .external_lex_state = 3}, - [1126] = {.lex_state = 41, .external_lex_state = 3}, - [1127] = {.lex_state = 21}, + [1124] = {.lex_state = 41}, + [1125] = {.lex_state = 41}, + [1126] = {.lex_state = 41}, + [1127] = {.lex_state = 41}, [1128] = {.lex_state = 41}, - [1129] = {.lex_state = 41}, + [1129] = {.lex_state = 8}, [1130] = {.lex_state = 41}, [1131] = {.lex_state = 41}, [1132] = {.lex_state = 41}, - [1133] = {.lex_state = 41}, - [1134] = {.lex_state = 41}, + [1133] = {.lex_state = 16}, + [1134] = {.lex_state = 41, .external_lex_state = 3}, [1135] = {.lex_state = 41}, [1136] = {.lex_state = 41}, [1137] = {.lex_state = 41}, @@ -6664,26 +6710,26 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1139] = {.lex_state = 41}, [1140] = {.lex_state = 41}, [1141] = {.lex_state = 41}, - [1142] = {.lex_state = 8}, + [1142] = {.lex_state = 41}, [1143] = {.lex_state = 41}, - [1144] = {.lex_state = 8}, + [1144] = {.lex_state = 41}, [1145] = {.lex_state = 41}, [1146] = {.lex_state = 41}, [1147] = {.lex_state = 41}, [1148] = {.lex_state = 41}, [1149] = {.lex_state = 41}, [1150] = {.lex_state = 41}, - [1151] = {.lex_state = 41, .external_lex_state = 3}, + [1151] = {.lex_state = 41}, [1152] = {.lex_state = 41}, - [1153] = {.lex_state = 41, .external_lex_state = 3}, + [1153] = {.lex_state = 41}, [1154] = {.lex_state = 41}, - [1155] = {.lex_state = 8}, + [1155] = {.lex_state = 41}, [1156] = {.lex_state = 41}, [1157] = {.lex_state = 41}, - [1158] = {.lex_state = 8}, - [1159] = {.lex_state = 41, .external_lex_state = 3}, + [1158] = {.lex_state = 41}, + [1159] = {.lex_state = 41}, [1160] = {.lex_state = 41}, - [1161] = {.lex_state = 8}, + [1161] = {.lex_state = 41}, [1162] = {.lex_state = 41}, [1163] = {.lex_state = 41}, [1164] = {.lex_state = 41}, @@ -6698,10 +6744,10 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1173] = {.lex_state = 41}, [1174] = {.lex_state = 41}, [1175] = {.lex_state = 41}, - [1176] = {.lex_state = 8, .external_lex_state = 3}, + [1176] = {.lex_state = 41}, [1177] = {.lex_state = 41}, [1178] = {.lex_state = 41}, - [1179] = {.lex_state = 21}, + [1179] = {.lex_state = 41}, [1180] = {.lex_state = 41}, [1181] = {.lex_state = 41}, [1182] = {.lex_state = 41}, @@ -6709,7 +6755,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1184] = {.lex_state = 41}, [1185] = {.lex_state = 41}, [1186] = {.lex_state = 41}, - [1187] = {.lex_state = 41}, + [1187] = {.lex_state = 16}, [1188] = {.lex_state = 41}, [1189] = {.lex_state = 41}, [1190] = {.lex_state = 41}, @@ -6717,10 +6763,10 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1192] = {.lex_state = 41}, [1193] = {.lex_state = 41}, [1194] = {.lex_state = 41}, - [1195] = {.lex_state = 41}, + [1195] = {.lex_state = 8}, [1196] = {.lex_state = 41}, [1197] = {.lex_state = 41}, - [1198] = {.lex_state = 41}, + [1198] = {.lex_state = 8}, [1199] = {.lex_state = 41}, [1200] = {.lex_state = 41}, [1201] = {.lex_state = 41}, @@ -6728,11 +6774,11 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1203] = {.lex_state = 41}, [1204] = {.lex_state = 41}, [1205] = {.lex_state = 41}, - [1206] = {.lex_state = 9}, + [1206] = {.lex_state = 41}, [1207] = {.lex_state = 41}, [1208] = {.lex_state = 41}, [1209] = {.lex_state = 41}, - [1210] = {.lex_state = 41}, + [1210] = {.lex_state = 41, .external_lex_state = 3}, [1211] = {.lex_state = 41}, [1212] = {.lex_state = 41}, [1213] = {.lex_state = 41}, @@ -6740,445 +6786,445 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1215] = {.lex_state = 41}, [1216] = {.lex_state = 41}, [1217] = {.lex_state = 41}, - [1218] = {.lex_state = 41}, + [1218] = {.lex_state = 8, .external_lex_state = 3}, [1219] = {.lex_state = 41}, - [1220] = {.lex_state = 41}, + [1220] = {.lex_state = 8, .external_lex_state = 3}, [1221] = {.lex_state = 41}, - [1222] = {.lex_state = 41}, + [1222] = {.lex_state = 41, .external_lex_state = 3}, [1223] = {.lex_state = 41}, - [1224] = {.lex_state = 41}, - [1225] = {.lex_state = 41}, - [1226] = {.lex_state = 41}, + [1224] = {.lex_state = 41, .external_lex_state = 3}, + [1225] = {.lex_state = 16}, + [1226] = {.lex_state = 8}, [1227] = {.lex_state = 41}, [1228] = {.lex_state = 41}, [1229] = {.lex_state = 41}, - [1230] = {.lex_state = 41}, - [1231] = {.lex_state = 9}, + [1230] = {.lex_state = 8, .external_lex_state = 3}, + [1231] = {.lex_state = 41}, [1232] = {.lex_state = 41}, [1233] = {.lex_state = 41}, [1234] = {.lex_state = 41}, [1235] = {.lex_state = 41}, [1236] = {.lex_state = 41}, - [1237] = {.lex_state = 8, .external_lex_state = 3}, - [1238] = {.lex_state = 8, .external_lex_state = 3}, + [1237] = {.lex_state = 41, .external_lex_state = 3}, + [1238] = {.lex_state = 41}, [1239] = {.lex_state = 41}, [1240] = {.lex_state = 41}, [1241] = {.lex_state = 41, .external_lex_state = 3}, - [1242] = {.lex_state = 41}, + [1242] = {.lex_state = 8}, [1243] = {.lex_state = 41}, [1244] = {.lex_state = 41}, [1245] = {.lex_state = 41}, - [1246] = {.lex_state = 41, .external_lex_state = 3}, + [1246] = {.lex_state = 41}, [1247] = {.lex_state = 41}, [1248] = {.lex_state = 41}, [1249] = {.lex_state = 41}, - [1250] = {.lex_state = 41, .external_lex_state = 3}, - [1251] = {.lex_state = 41}, - [1252] = {.lex_state = 8}, + [1250] = {.lex_state = 8}, + [1251] = {.lex_state = 41, .external_lex_state = 3}, + [1252] = {.lex_state = 41}, [1253] = {.lex_state = 41}, [1254] = {.lex_state = 41}, [1255] = {.lex_state = 41}, [1256] = {.lex_state = 41}, - [1257] = {.lex_state = 21}, - [1258] = {.lex_state = 9, .external_lex_state = 3}, + [1257] = {.lex_state = 41}, + [1258] = {.lex_state = 41}, [1259] = {.lex_state = 41}, [1260] = {.lex_state = 41}, [1261] = {.lex_state = 41}, - [1262] = {.lex_state = 41}, + [1262] = {.lex_state = 8}, [1263] = {.lex_state = 41}, - [1264] = {.lex_state = 41}, - [1265] = {.lex_state = 21}, - [1266] = {.lex_state = 41}, + [1264] = {.lex_state = 41, .external_lex_state = 3}, + [1265] = {.lex_state = 41}, + [1266] = {.lex_state = 16}, [1267] = {.lex_state = 41}, - [1268] = {.lex_state = 41}, + [1268] = {.lex_state = 41, .external_lex_state = 3}, [1269] = {.lex_state = 41}, - [1270] = {.lex_state = 21}, + [1270] = {.lex_state = 41}, [1271] = {.lex_state = 41}, [1272] = {.lex_state = 41}, - [1273] = {.lex_state = 41}, + [1273] = {.lex_state = 8}, [1274] = {.lex_state = 41}, - [1275] = {.lex_state = 8}, + [1275] = {.lex_state = 16, .external_lex_state = 3}, [1276] = {.lex_state = 41}, [1277] = {.lex_state = 41}, [1278] = {.lex_state = 41}, [1279] = {.lex_state = 41}, [1280] = {.lex_state = 41}, - [1281] = {.lex_state = 9, .external_lex_state = 3}, + [1281] = {.lex_state = 41}, [1282] = {.lex_state = 41}, - [1283] = {.lex_state = 41}, + [1283] = {.lex_state = 8}, [1284] = {.lex_state = 41}, [1285] = {.lex_state = 41}, - [1286] = {.lex_state = 41}, - [1287] = {.lex_state = 41, .external_lex_state = 3}, + [1286] = {.lex_state = 16}, + [1287] = {.lex_state = 9}, [1288] = {.lex_state = 41, .external_lex_state = 3}, [1289] = {.lex_state = 41}, [1290] = {.lex_state = 41}, - [1291] = {.lex_state = 9, .external_lex_state = 3}, + [1291] = {.lex_state = 41}, [1292] = {.lex_state = 41}, [1293] = {.lex_state = 41}, [1294] = {.lex_state = 41}, [1295] = {.lex_state = 41, .external_lex_state = 3}, - [1296] = {.lex_state = 41, .external_lex_state = 3}, - [1297] = {.lex_state = 41}, - [1298] = {.lex_state = 21}, - [1299] = {.lex_state = 41}, + [1296] = {.lex_state = 41}, + [1297] = {.lex_state = 8}, + [1298] = {.lex_state = 16, .external_lex_state = 3}, + [1299] = {.lex_state = 8}, [1300] = {.lex_state = 41}, [1301] = {.lex_state = 41}, - [1302] = {.lex_state = 41}, - [1303] = {.lex_state = 41}, + [1302] = {.lex_state = 16}, + [1303] = {.lex_state = 8}, [1304] = {.lex_state = 41}, - [1305] = {.lex_state = 41}, - [1306] = {.lex_state = 9, .external_lex_state = 3}, - [1307] = {.lex_state = 41}, + [1305] = {.lex_state = 16, .external_lex_state = 3}, + [1306] = {.lex_state = 8}, + [1307] = {.lex_state = 16}, [1308] = {.lex_state = 41}, - [1309] = {.lex_state = 41}, - [1310] = {.lex_state = 41}, - [1311] = {.lex_state = 41}, + [1309] = {.lex_state = 41, .external_lex_state = 3}, + [1310] = {.lex_state = 8}, + [1311] = {.lex_state = 9}, [1312] = {.lex_state = 41, .external_lex_state = 3}, [1313] = {.lex_state = 41}, - [1314] = {.lex_state = 41}, + [1314] = {.lex_state = 8}, [1315] = {.lex_state = 41}, [1316] = {.lex_state = 41}, [1317] = {.lex_state = 41}, [1318] = {.lex_state = 41}, [1319] = {.lex_state = 41}, [1320] = {.lex_state = 41}, - [1321] = {.lex_state = 41}, + [1321] = {.lex_state = 8}, [1322] = {.lex_state = 41}, [1323] = {.lex_state = 41}, [1324] = {.lex_state = 41}, [1325] = {.lex_state = 41}, [1326] = {.lex_state = 41}, - [1327] = {.lex_state = 41}, + [1327] = {.lex_state = 8}, [1328] = {.lex_state = 41}, - [1329] = {.lex_state = 21}, - [1330] = {.lex_state = 41}, + [1329] = {.lex_state = 8}, + [1330] = {.lex_state = 9}, [1331] = {.lex_state = 41}, [1332] = {.lex_state = 41}, - [1333] = {.lex_state = 41, .external_lex_state = 3}, + [1333] = {.lex_state = 41}, [1334] = {.lex_state = 41}, [1335] = {.lex_state = 41}, - [1336] = {.lex_state = 41}, - [1337] = {.lex_state = 21}, + [1336] = {.lex_state = 9}, + [1337] = {.lex_state = 8}, [1338] = {.lex_state = 41}, [1339] = {.lex_state = 41}, [1340] = {.lex_state = 41}, - [1341] = {.lex_state = 41}, - [1342] = {.lex_state = 41}, + [1341] = {.lex_state = 16}, + [1342] = {.lex_state = 8}, [1343] = {.lex_state = 8}, [1344] = {.lex_state = 41}, [1345] = {.lex_state = 41}, - [1346] = {.lex_state = 41}, + [1346] = {.lex_state = 41, .external_lex_state = 3}, [1347] = {.lex_state = 41}, - [1348] = {.lex_state = 8}, + [1348] = {.lex_state = 16}, [1349] = {.lex_state = 41}, - [1350] = {.lex_state = 41, .external_lex_state = 3}, - [1351] = {.lex_state = 41, .external_lex_state = 3}, + [1350] = {.lex_state = 41}, + [1351] = {.lex_state = 41}, [1352] = {.lex_state = 41}, [1353] = {.lex_state = 41, .external_lex_state = 3}, - [1354] = {.lex_state = 21}, - [1355] = {.lex_state = 41}, + [1354] = {.lex_state = 41}, + [1355] = {.lex_state = 16, .external_lex_state = 3}, [1356] = {.lex_state = 41}, [1357] = {.lex_state = 41}, - [1358] = {.lex_state = 41, .external_lex_state = 3}, - [1359] = {.lex_state = 21}, - [1360] = {.lex_state = 9}, + [1358] = {.lex_state = 8}, + [1359] = {.lex_state = 41}, + [1360] = {.lex_state = 41}, [1361] = {.lex_state = 41}, - [1362] = {.lex_state = 41}, + [1362] = {.lex_state = 9}, [1363] = {.lex_state = 41}, - [1364] = {.lex_state = 41}, + [1364] = {.lex_state = 41, .external_lex_state = 3}, [1365] = {.lex_state = 8}, - [1366] = {.lex_state = 21}, - [1367] = {.lex_state = 41, .external_lex_state = 3}, - [1368] = {.lex_state = 41, .external_lex_state = 3}, - [1369] = {.lex_state = 41, .external_lex_state = 3}, + [1366] = {.lex_state = 41}, + [1367] = {.lex_state = 41}, + [1368] = {.lex_state = 41}, + [1369] = {.lex_state = 41}, [1370] = {.lex_state = 41}, [1371] = {.lex_state = 41}, - [1372] = {.lex_state = 41}, + [1372] = {.lex_state = 41, .external_lex_state = 3}, [1373] = {.lex_state = 41}, - [1374] = {.lex_state = 41, .external_lex_state = 3}, - [1375] = {.lex_state = 41}, - [1376] = {.lex_state = 41}, - [1377] = {.lex_state = 8}, - [1378] = {.lex_state = 41}, - [1379] = {.lex_state = 41}, + [1374] = {.lex_state = 41}, + [1375] = {.lex_state = 16}, + [1376] = {.lex_state = 41, .external_lex_state = 3}, + [1377] = {.lex_state = 41}, + [1378] = {.lex_state = 41, .external_lex_state = 3}, + [1379] = {.lex_state = 16}, [1380] = {.lex_state = 41}, - [1381] = {.lex_state = 21}, + [1381] = {.lex_state = 41}, [1382] = {.lex_state = 41}, [1383] = {.lex_state = 41}, - [1384] = {.lex_state = 9}, - [1385] = {.lex_state = 8}, - [1386] = {.lex_state = 41}, + [1384] = {.lex_state = 41, .external_lex_state = 3}, + [1385] = {.lex_state = 41}, + [1386] = {.lex_state = 16}, [1387] = {.lex_state = 41}, [1388] = {.lex_state = 41, .external_lex_state = 3}, [1389] = {.lex_state = 41, .external_lex_state = 3}, - [1390] = {.lex_state = 21}, - [1391] = {.lex_state = 41, .external_lex_state = 3}, - [1392] = {.lex_state = 41, .external_lex_state = 3}, + [1390] = {.lex_state = 41, .external_lex_state = 3}, + [1391] = {.lex_state = 41}, + [1392] = {.lex_state = 41}, [1393] = {.lex_state = 41}, - [1394] = {.lex_state = 41, .external_lex_state = 3}, + [1394] = {.lex_state = 41}, [1395] = {.lex_state = 41}, - [1396] = {.lex_state = 21}, + [1396] = {.lex_state = 41, .external_lex_state = 3}, [1397] = {.lex_state = 41, .external_lex_state = 3}, [1398] = {.lex_state = 41}, - [1399] = {.lex_state = 41, .external_lex_state = 3}, - [1400] = {.lex_state = 41}, - [1401] = {.lex_state = 41}, + [1399] = {.lex_state = 8}, + [1400] = {.lex_state = 41, .external_lex_state = 3}, + [1401] = {.lex_state = 41, .external_lex_state = 3}, [1402] = {.lex_state = 41}, [1403] = {.lex_state = 41}, - [1404] = {.lex_state = 41, .external_lex_state = 3}, - [1405] = {.lex_state = 41}, - [1406] = {.lex_state = 41, .external_lex_state = 3}, - [1407] = {.lex_state = 41, .external_lex_state = 3}, - [1408] = {.lex_state = 9}, - [1409] = {.lex_state = 41, .external_lex_state = 3}, + [1404] = {.lex_state = 16}, + [1405] = {.lex_state = 8}, + [1406] = {.lex_state = 41}, + [1407] = {.lex_state = 41}, + [1408] = {.lex_state = 41, .external_lex_state = 3}, + [1409] = {.lex_state = 16}, [1410] = {.lex_state = 41, .external_lex_state = 3}, - [1411] = {.lex_state = 41}, - [1412] = {.lex_state = 41}, - [1413] = {.lex_state = 41}, - [1414] = {.lex_state = 41}, - [1415] = {.lex_state = 41}, - [1416] = {.lex_state = 41, .external_lex_state = 3}, - [1417] = {.lex_state = 41, .external_lex_state = 3}, + [1411] = {.lex_state = 41, .external_lex_state = 3}, + [1412] = {.lex_state = 41, .external_lex_state = 3}, + [1413] = {.lex_state = 8}, + [1414] = {.lex_state = 41, .external_lex_state = 3}, + [1415] = {.lex_state = 41, .external_lex_state = 3}, + [1416] = {.lex_state = 16}, + [1417] = {.lex_state = 41}, [1418] = {.lex_state = 41, .external_lex_state = 3}, [1419] = {.lex_state = 41}, - [1420] = {.lex_state = 41}, + [1420] = {.lex_state = 41, .external_lex_state = 3}, [1421] = {.lex_state = 41}, [1422] = {.lex_state = 41}, [1423] = {.lex_state = 41}, - [1424] = {.lex_state = 21}, + [1424] = {.lex_state = 41}, [1425] = {.lex_state = 41}, - [1426] = {.lex_state = 41, .external_lex_state = 3}, + [1426] = {.lex_state = 8}, [1427] = {.lex_state = 41}, - [1428] = {.lex_state = 41}, + [1428] = {.lex_state = 16}, [1429] = {.lex_state = 41, .external_lex_state = 3}, - [1430] = {.lex_state = 41, .external_lex_state = 3}, + [1430] = {.lex_state = 41}, [1431] = {.lex_state = 41}, - [1432] = {.lex_state = 41, .external_lex_state = 3}, - [1433] = {.lex_state = 21}, - [1434] = {.lex_state = 41}, + [1432] = {.lex_state = 41}, + [1433] = {.lex_state = 41}, + [1434] = {.lex_state = 41, .external_lex_state = 3}, [1435] = {.lex_state = 41}, - [1436] = {.lex_state = 41}, - [1437] = {.lex_state = 41}, - [1438] = {.lex_state = 41}, - [1439] = {.lex_state = 21}, - [1440] = {.lex_state = 41, .external_lex_state = 3}, - [1441] = {.lex_state = 41}, + [1436] = {.lex_state = 41, .external_lex_state = 3}, + [1437] = {.lex_state = 41, .external_lex_state = 3}, + [1438] = {.lex_state = 8}, + [1439] = {.lex_state = 16}, + [1440] = {.lex_state = 41}, + [1441] = {.lex_state = 41, .external_lex_state = 3}, [1442] = {.lex_state = 41}, - [1443] = {.lex_state = 41, .external_lex_state = 3}, - [1444] = {.lex_state = 41, .external_lex_state = 3}, - [1445] = {.lex_state = 41, .external_lex_state = 3}, + [1443] = {.lex_state = 41}, + [1444] = {.lex_state = 8}, + [1445] = {.lex_state = 41}, [1446] = {.lex_state = 41, .external_lex_state = 3}, - [1447] = {.lex_state = 41}, - [1448] = {.lex_state = 8}, + [1447] = {.lex_state = 41, .external_lex_state = 3}, + [1448] = {.lex_state = 41}, [1449] = {.lex_state = 41}, - [1450] = {.lex_state = 41}, - [1451] = {.lex_state = 41, .external_lex_state = 3}, + [1450] = {.lex_state = 41, .external_lex_state = 3}, + [1451] = {.lex_state = 16}, [1452] = {.lex_state = 41}, [1453] = {.lex_state = 41}, - [1454] = {.lex_state = 41, .external_lex_state = 3}, - [1455] = {.lex_state = 41, .external_lex_state = 3}, - [1456] = {.lex_state = 41, .external_lex_state = 3}, - [1457] = {.lex_state = 41, .external_lex_state = 3}, - [1458] = {.lex_state = 41}, - [1459] = {.lex_state = 41, .external_lex_state = 3}, + [1454] = {.lex_state = 41}, + [1455] = {.lex_state = 41}, + [1456] = {.lex_state = 41}, + [1457] = {.lex_state = 41}, + [1458] = {.lex_state = 9}, + [1459] = {.lex_state = 41}, [1460] = {.lex_state = 41}, - [1461] = {.lex_state = 41}, - [1462] = {.lex_state = 41}, - [1463] = {.lex_state = 41, .external_lex_state = 3}, - [1464] = {.lex_state = 41}, - [1465] = {.lex_state = 41}, - [1466] = {.lex_state = 21}, + [1461] = {.lex_state = 41, .external_lex_state = 3}, + [1462] = {.lex_state = 41, .external_lex_state = 3}, + [1463] = {.lex_state = 41}, + [1464] = {.lex_state = 41, .external_lex_state = 3}, + [1465] = {.lex_state = 8}, + [1466] = {.lex_state = 41}, [1467] = {.lex_state = 41}, - [1468] = {.lex_state = 41, .external_lex_state = 3}, + [1468] = {.lex_state = 41}, [1469] = {.lex_state = 41}, - [1470] = {.lex_state = 41}, + [1470] = {.lex_state = 8}, [1471] = {.lex_state = 41}, - [1472] = {.lex_state = 41, .external_lex_state = 3}, - [1473] = {.lex_state = 41, .external_lex_state = 3}, + [1472] = {.lex_state = 41}, + [1473] = {.lex_state = 41}, [1474] = {.lex_state = 41}, [1475] = {.lex_state = 41, .external_lex_state = 3}, - [1476] = {.lex_state = 21}, - [1477] = {.lex_state = 41}, - [1478] = {.lex_state = 41, .external_lex_state = 3}, + [1476] = {.lex_state = 41, .external_lex_state = 3}, + [1477] = {.lex_state = 41, .external_lex_state = 3}, + [1478] = {.lex_state = 8}, [1479] = {.lex_state = 41}, - [1480] = {.lex_state = 41, .external_lex_state = 3}, - [1481] = {.lex_state = 41, .external_lex_state = 3}, + [1480] = {.lex_state = 41}, + [1481] = {.lex_state = 41}, [1482] = {.lex_state = 41}, [1483] = {.lex_state = 41}, - [1484] = {.lex_state = 41}, - [1485] = {.lex_state = 41}, - [1486] = {.lex_state = 41}, + [1484] = {.lex_state = 41, .external_lex_state = 3}, + [1485] = {.lex_state = 8}, + [1486] = {.lex_state = 16}, [1487] = {.lex_state = 41}, - [1488] = {.lex_state = 41}, + [1488] = {.lex_state = 41, .external_lex_state = 3}, [1489] = {.lex_state = 41}, [1490] = {.lex_state = 41}, [1491] = {.lex_state = 41}, [1492] = {.lex_state = 41}, - [1493] = {.lex_state = 9}, - [1494] = {.lex_state = 41}, - [1495] = {.lex_state = 41}, - [1496] = {.lex_state = 21}, - [1497] = {.lex_state = 41, .external_lex_state = 3}, - [1498] = {.lex_state = 41, .external_lex_state = 3}, - [1499] = {.lex_state = 41, .external_lex_state = 3}, - [1500] = {.lex_state = 9}, - [1501] = {.lex_state = 8}, - [1502] = {.lex_state = 41}, - [1503] = {.lex_state = 21}, - [1504] = {.lex_state = 21}, - [1505] = {.lex_state = 41}, - [1506] = {.lex_state = 41}, - [1507] = {.lex_state = 9}, + [1493] = {.lex_state = 41}, + [1494] = {.lex_state = 41, .external_lex_state = 3}, + [1495] = {.lex_state = 41, .external_lex_state = 3}, + [1496] = {.lex_state = 16}, + [1497] = {.lex_state = 41}, + [1498] = {.lex_state = 8}, + [1499] = {.lex_state = 41}, + [1500] = {.lex_state = 41}, + [1501] = {.lex_state = 41}, + [1502] = {.lex_state = 8}, + [1503] = {.lex_state = 8}, + [1504] = {.lex_state = 41}, + [1505] = {.lex_state = 16}, + [1506] = {.lex_state = 41, .external_lex_state = 3}, + [1507] = {.lex_state = 16}, [1508] = {.lex_state = 41}, [1509] = {.lex_state = 41}, - [1510] = {.lex_state = 41, .external_lex_state = 3}, - [1511] = {.lex_state = 41}, - [1512] = {.lex_state = 41}, - [1513] = {.lex_state = 41, .external_lex_state = 3}, - [1514] = {.lex_state = 41}, + [1510] = {.lex_state = 41}, + [1511] = {.lex_state = 41, .external_lex_state = 3}, + [1512] = {.lex_state = 41, .external_lex_state = 3}, + [1513] = {.lex_state = 41}, + [1514] = {.lex_state = 16}, [1515] = {.lex_state = 41}, - [1516] = {.lex_state = 41, .external_lex_state = 3}, + [1516] = {.lex_state = 41}, [1517] = {.lex_state = 41}, - [1518] = {.lex_state = 41}, - [1519] = {.lex_state = 41}, - [1520] = {.lex_state = 41}, - [1521] = {.lex_state = 41}, - [1522] = {.lex_state = 41}, - [1523] = {.lex_state = 41}, + [1518] = {.lex_state = 16}, + [1519] = {.lex_state = 16}, + [1520] = {.lex_state = 41, .external_lex_state = 3}, + [1521] = {.lex_state = 41, .external_lex_state = 3}, + [1522] = {.lex_state = 16}, + [1523] = {.lex_state = 8}, [1524] = {.lex_state = 41}, - [1525] = {.lex_state = 41, .external_lex_state = 3}, - [1526] = {.lex_state = 8}, - [1527] = {.lex_state = 8}, + [1525] = {.lex_state = 16}, + [1526] = {.lex_state = 41, .external_lex_state = 3}, + [1527] = {.lex_state = 41}, [1528] = {.lex_state = 41}, - [1529] = {.lex_state = 41, .external_lex_state = 3}, - [1530] = {.lex_state = 41, .external_lex_state = 3}, - [1531] = {.lex_state = 9}, - [1532] = {.lex_state = 41}, + [1529] = {.lex_state = 16}, + [1530] = {.lex_state = 41}, + [1531] = {.lex_state = 41}, + [1532] = {.lex_state = 41, .external_lex_state = 3}, [1533] = {.lex_state = 41}, - [1534] = {.lex_state = 8}, + [1534] = {.lex_state = 41}, [1535] = {.lex_state = 41}, - [1536] = {.lex_state = 41}, + [1536] = {.lex_state = 41, .external_lex_state = 3}, [1537] = {.lex_state = 41}, - [1538] = {.lex_state = 41}, + [1538] = {.lex_state = 41, .external_lex_state = 3}, [1539] = {.lex_state = 41}, - [1540] = {.lex_state = 41, .external_lex_state = 3}, + [1540] = {.lex_state = 41}, [1541] = {.lex_state = 41}, [1542] = {.lex_state = 41}, [1543] = {.lex_state = 41}, - [1544] = {.lex_state = 41}, + [1544] = {.lex_state = 16}, [1545] = {.lex_state = 41, .external_lex_state = 3}, [1546] = {.lex_state = 41}, [1547] = {.lex_state = 41, .external_lex_state = 3}, [1548] = {.lex_state = 41}, [1549] = {.lex_state = 41}, - [1550] = {.lex_state = 41, .external_lex_state = 3}, - [1551] = {.lex_state = 9}, + [1550] = {.lex_state = 8}, + [1551] = {.lex_state = 41, .external_lex_state = 3}, [1552] = {.lex_state = 41}, - [1553] = {.lex_state = 41}, + [1553] = {.lex_state = 41, .external_lex_state = 3}, [1554] = {.lex_state = 41}, - [1555] = {.lex_state = 41, .external_lex_state = 3}, + [1555] = {.lex_state = 41}, [1556] = {.lex_state = 41, .external_lex_state = 3}, [1557] = {.lex_state = 41}, - [1558] = {.lex_state = 41}, + [1558] = {.lex_state = 41, .external_lex_state = 3}, [1559] = {.lex_state = 41}, - [1560] = {.lex_state = 41, .external_lex_state = 3}, - [1561] = {.lex_state = 8}, - [1562] = {.lex_state = 8}, - [1563] = {.lex_state = 41}, - [1564] = {.lex_state = 41}, + [1560] = {.lex_state = 16}, + [1561] = {.lex_state = 41, .external_lex_state = 3}, + [1562] = {.lex_state = 41}, + [1563] = {.lex_state = 41, .external_lex_state = 3}, + [1564] = {.lex_state = 9}, [1565] = {.lex_state = 41}, [1566] = {.lex_state = 41}, [1567] = {.lex_state = 41}, - [1568] = {.lex_state = 41, .external_lex_state = 3}, - [1569] = {.lex_state = 41, .external_lex_state = 3}, + [1568] = {.lex_state = 41}, + [1569] = {.lex_state = 41}, [1570] = {.lex_state = 41}, [1571] = {.lex_state = 41}, [1572] = {.lex_state = 41}, - [1573] = {.lex_state = 41, .external_lex_state = 3}, + [1573] = {.lex_state = 41}, [1574] = {.lex_state = 41, .external_lex_state = 3}, [1575] = {.lex_state = 41}, [1576] = {.lex_state = 41}, - [1577] = {.lex_state = 41, .external_lex_state = 3}, + [1577] = {.lex_state = 41}, [1578] = {.lex_state = 41}, - [1579] = {.lex_state = 41}, - [1580] = {.lex_state = 41}, - [1581] = {.lex_state = 41}, + [1579] = {.lex_state = 41, .external_lex_state = 3}, + [1580] = {.lex_state = 41, .external_lex_state = 3}, + [1581] = {.lex_state = 41, .external_lex_state = 3}, [1582] = {.lex_state = 41}, [1583] = {.lex_state = 41}, - [1584] = {.lex_state = 41, .external_lex_state = 3}, + [1584] = {.lex_state = 41}, [1585] = {.lex_state = 41}, [1586] = {.lex_state = 8}, [1587] = {.lex_state = 41}, - [1588] = {.lex_state = 41}, - [1589] = {.lex_state = 8}, - [1590] = {.lex_state = 41, .external_lex_state = 3}, - [1591] = {.lex_state = 41}, + [1588] = {.lex_state = 41, .external_lex_state = 3}, + [1589] = {.lex_state = 41}, + [1590] = {.lex_state = 41}, + [1591] = {.lex_state = 41, .external_lex_state = 3}, [1592] = {.lex_state = 41}, - [1593] = {.lex_state = 41}, + [1593] = {.lex_state = 41, .external_lex_state = 3}, [1594] = {.lex_state = 41}, - [1595] = {.lex_state = 41, .external_lex_state = 3}, - [1596] = {.lex_state = 9}, + [1595] = {.lex_state = 41}, + [1596] = {.lex_state = 41, .external_lex_state = 3}, [1597] = {.lex_state = 41}, - [1598] = {.lex_state = 41}, - [1599] = {.lex_state = 41, .external_lex_state = 3}, + [1598] = {.lex_state = 41, .external_lex_state = 3}, + [1599] = {.lex_state = 16}, [1600] = {.lex_state = 41}, - [1601] = {.lex_state = 41, .external_lex_state = 3}, + [1601] = {.lex_state = 41}, [1602] = {.lex_state = 41}, - [1603] = {.lex_state = 41, .external_lex_state = 3}, + [1603] = {.lex_state = 41}, [1604] = {.lex_state = 41}, - [1605] = {.lex_state = 41, .external_lex_state = 3}, - [1606] = {.lex_state = 8}, + [1605] = {.lex_state = 41}, + [1606] = {.lex_state = 41}, [1607] = {.lex_state = 41}, - [1608] = {.lex_state = 41, .external_lex_state = 3}, - [1609] = {.lex_state = 8}, + [1608] = {.lex_state = 41}, + [1609] = {.lex_state = 41}, [1610] = {.lex_state = 41}, - [1611] = {.lex_state = 41}, - [1612] = {.lex_state = 41, .external_lex_state = 3}, - [1613] = {.lex_state = 41, .external_lex_state = 3}, - [1614] = {.lex_state = 41}, + [1611] = {.lex_state = 8}, + [1612] = {.lex_state = 41}, + [1613] = {.lex_state = 41}, + [1614] = {.lex_state = 41, .external_lex_state = 3}, [1615] = {.lex_state = 41}, - [1616] = {.lex_state = 41, .external_lex_state = 3}, - [1617] = {.lex_state = 41}, + [1616] = {.lex_state = 41}, + [1617] = {.lex_state = 8}, [1618] = {.lex_state = 41}, - [1619] = {.lex_state = 41, .external_lex_state = 3}, + [1619] = {.lex_state = 41}, [1620] = {.lex_state = 41}, [1621] = {.lex_state = 41}, - [1622] = {.lex_state = 41, .external_lex_state = 3}, + [1622] = {.lex_state = 8}, [1623] = {.lex_state = 41}, - [1624] = {.lex_state = 41, .external_lex_state = 3}, - [1625] = {.lex_state = 41, .external_lex_state = 3}, + [1624] = {.lex_state = 41}, + [1625] = {.lex_state = 41}, [1626] = {.lex_state = 41}, [1627] = {.lex_state = 41}, - [1628] = {.lex_state = 41}, + [1628] = {.lex_state = 41, .external_lex_state = 3}, [1629] = {.lex_state = 41}, [1630] = {.lex_state = 41}, [1631] = {.lex_state = 41}, - [1632] = {.lex_state = 41, .external_lex_state = 3}, - [1633] = {.lex_state = 8}, - [1634] = {.lex_state = 41}, - [1635] = {.lex_state = 41}, - [1636] = {.lex_state = 41}, - [1637] = {.lex_state = 41}, + [1632] = {.lex_state = 41}, + [1633] = {.lex_state = 41}, + [1634] = {.lex_state = 8}, + [1635] = {.lex_state = 41, .external_lex_state = 3}, + [1636] = {.lex_state = 41, .external_lex_state = 3}, + [1637] = {.lex_state = 41, .external_lex_state = 3}, [1638] = {.lex_state = 41}, - [1639] = {.lex_state = 41, .external_lex_state = 3}, - [1640] = {.lex_state = 41}, + [1639] = {.lex_state = 41}, + [1640] = {.lex_state = 41, .external_lex_state = 3}, [1641] = {.lex_state = 41}, - [1642] = {.lex_state = 41, .external_lex_state = 3}, + [1642] = {.lex_state = 41}, [1643] = {.lex_state = 41, .external_lex_state = 3}, - [1644] = {.lex_state = 41}, + [1644] = {.lex_state = 9}, [1645] = {.lex_state = 41}, [1646] = {.lex_state = 41}, [1647] = {.lex_state = 41}, - [1648] = {.lex_state = 21}, - [1649] = {.lex_state = 41}, - [1650] = {.lex_state = 41}, - [1651] = {.lex_state = 41}, - [1652] = {.lex_state = 41, .external_lex_state = 3}, - [1653] = {.lex_state = 41}, + [1648] = {.lex_state = 41}, + [1649] = {.lex_state = 41, .external_lex_state = 3}, + [1650] = {.lex_state = 41, .external_lex_state = 3}, + [1651] = {.lex_state = 41, .external_lex_state = 3}, + [1652] = {.lex_state = 41}, + [1653] = {.lex_state = 41, .external_lex_state = 3}, [1654] = {.lex_state = 41}, [1655] = {.lex_state = 41}, - [1656] = {.lex_state = 8}, + [1656] = {.lex_state = 41}, [1657] = {.lex_state = 41}, [1658] = {.lex_state = 41}, [1659] = {.lex_state = 41}, @@ -7186,67 +7232,93 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1661] = {.lex_state = 41}, [1662] = {.lex_state = 41}, [1663] = {.lex_state = 41}, - [1664] = {.lex_state = 41}, + [1664] = {.lex_state = 41, .external_lex_state = 3}, [1665] = {.lex_state = 41}, - [1666] = {.lex_state = 8}, - [1667] = {.lex_state = 8}, - [1668] = {.lex_state = 41}, - [1669] = {.lex_state = 41}, - [1670] = {.lex_state = 8}, + [1666] = {.lex_state = 41}, + [1667] = {.lex_state = 41}, + [1668] = {.lex_state = 41, .external_lex_state = 3}, + [1669] = {.lex_state = 41, .external_lex_state = 3}, + [1670] = {.lex_state = 41}, [1671] = {.lex_state = 41}, - [1672] = {.lex_state = 8}, - [1673] = {.lex_state = 8}, + [1672] = {.lex_state = 41, .external_lex_state = 3}, + [1673] = {.lex_state = 41}, [1674] = {.lex_state = 41}, - [1675] = {.lex_state = 8}, + [1675] = {.lex_state = 41}, [1676] = {.lex_state = 41}, [1677] = {.lex_state = 41}, - [1678] = {.lex_state = 41}, + [1678] = {.lex_state = 41, .external_lex_state = 3}, [1679] = {.lex_state = 41}, - [1680] = {.lex_state = 21}, + [1680] = {.lex_state = 41}, [1681] = {.lex_state = 41}, - [1682] = {.lex_state = 41, .external_lex_state = 3}, + [1682] = {.lex_state = 41}, [1683] = {.lex_state = 41}, - [1684] = {.lex_state = 41}, - [1685] = {.lex_state = 41}, + [1684] = {.lex_state = 41, .external_lex_state = 3}, + [1685] = {.lex_state = 41, .external_lex_state = 3}, [1686] = {.lex_state = 41}, [1687] = {.lex_state = 41}, - [1688] = {.lex_state = 41}, + [1688] = {.lex_state = 41, .external_lex_state = 3}, [1689] = {.lex_state = 41}, [1690] = {.lex_state = 41}, [1691] = {.lex_state = 41}, - [1692] = {.lex_state = 41}, - [1693] = {.lex_state = 41, .external_lex_state = 3}, + [1692] = {.lex_state = 8}, + [1693] = {.lex_state = 41}, [1694] = {.lex_state = 41}, [1695] = {.lex_state = 41}, [1696] = {.lex_state = 41}, - [1697] = {.lex_state = 41, .external_lex_state = 3}, - [1698] = {.lex_state = 41}, - [1699] = {.lex_state = 41}, + [1697] = {.lex_state = 41}, + [1698] = {.lex_state = 8}, + [1699] = {.lex_state = 8}, [1700] = {.lex_state = 41}, [1701] = {.lex_state = 8}, - [1702] = {.lex_state = 8}, - [1703] = {.lex_state = 21}, - [1704] = {.lex_state = 8}, + [1702] = {.lex_state = 41}, + [1703] = {.lex_state = 41}, + [1704] = {.lex_state = 41}, [1705] = {.lex_state = 41}, [1706] = {.lex_state = 41}, [1707] = {.lex_state = 41}, - [1708] = {.lex_state = 41}, + [1708] = {.lex_state = 16}, [1709] = {.lex_state = 41}, [1710] = {.lex_state = 41}, [1711] = {.lex_state = 41}, [1712] = {.lex_state = 41}, - [1713] = {.lex_state = 8}, + [1713] = {.lex_state = 41}, [1714] = {.lex_state = 41}, - [1715] = {.lex_state = 41, .external_lex_state = 3}, + [1715] = {.lex_state = 41}, [1716] = {.lex_state = 41}, - [1717] = {.lex_state = 41}, - [1718] = {.lex_state = 41}, - [1719] = {.lex_state = 41, .external_lex_state = 3}, - [1720] = {.lex_state = 41, .external_lex_state = 3}, + [1717] = {.lex_state = 41, .external_lex_state = 3}, + [1718] = {.lex_state = 41, .external_lex_state = 3}, + [1719] = {.lex_state = 41}, + [1720] = {.lex_state = 41}, [1721] = {.lex_state = 41}, - [1722] = {.lex_state = 41, .external_lex_state = 3}, + [1722] = {.lex_state = 41}, [1723] = {.lex_state = 41}, [1724] = {.lex_state = 41}, + [1725] = {.lex_state = 41}, + [1726] = {.lex_state = 16}, + [1727] = {.lex_state = 8}, + [1728] = {.lex_state = 41, .external_lex_state = 3}, + [1729] = {.lex_state = 41}, + [1730] = {.lex_state = 8}, + [1731] = {.lex_state = 41, .external_lex_state = 3}, + [1732] = {.lex_state = 16}, + [1733] = {.lex_state = 41, .external_lex_state = 3}, + [1734] = {.lex_state = 41}, + [1735] = {.lex_state = 41, .external_lex_state = 3}, + [1736] = {.lex_state = 41}, + [1737] = {.lex_state = 41}, + [1738] = {.lex_state = 41}, + [1739] = {.lex_state = 41, .external_lex_state = 3}, + [1740] = {.lex_state = 41, .external_lex_state = 3}, + [1741] = {.lex_state = 41}, + [1742] = {.lex_state = 41, .external_lex_state = 3}, + [1743] = {.lex_state = 41}, + [1744] = {.lex_state = 41}, + [1745] = {.lex_state = 41}, + [1746] = {.lex_state = 41, .external_lex_state = 3}, + [1747] = {.lex_state = 41}, + [1748] = {.lex_state = 8}, + [1749] = {.lex_state = 16}, + [1750] = {.lex_state = 41, .external_lex_state = 3}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -7309,6 +7381,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_PERCENT] = ACTIONS(1), [anon_sym_await] = ACTIONS(1), [anon_sym_PIPE_GT] = ACTIONS(1), + [anon_sym_LPAREN2] = ACTIONS(1), [anon_sym_LBRACK2] = ACTIONS(1), [anon_sym_spawn] = ACTIONS(1), [anon_sym_yield] = ACTIONS(1), @@ -7316,6 +7389,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_recv] = ACTIONS(1), [anon_sym_perform] = ACTIONS(1), [anon_sym_resume] = ACTIONS(1), + [anon_sym_LT2] = ACTIONS(1), [anon_sym_DOT_DOT] = ACTIONS(1), [anon_sym_DOT_DOT_DOT] = ACTIONS(1), [anon_sym_state] = ACTIONS(1), @@ -7336,51 +7410,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__statement_break] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(1614), - [sym_statement] = STATE(6), - [sym_import_statement] = STATE(1367), - [sym_namespace_declaration] = STATE(1367), - [sym_let_declaration] = STATE(1367), - [sym_assignment] = STATE(1367), - [sym_function_declaration] = STATE(1367), - [sym_extern_declaration] = STATE(1367), - [sym_type_declaration] = STATE(1367), - [sym_effect_declaration] = STATE(1367), - [sym_expression_statement] = STATE(1367), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1367), - [sym_signature_declaration] = STATE(1367), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_source_file] = STATE(1430), + [sym_statement] = STATE(7), + [sym_import_statement] = STATE(1477), + [sym_namespace_declaration] = STATE(1477), + [sym_let_declaration] = STATE(1477), + [sym_assignment] = STATE(1477), + [sym_function_declaration] = STATE(1477), + [sym_extern_declaration] = STATE(1477), + [sym_type_declaration] = STATE(1477), + [sym_effect_declaration] = STATE(1477), + [sym_expression_statement] = STATE(1477), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1477), + [sym_signature_declaration] = STATE(1477), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(6), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(7), + [aux_sym_doc_comment_repeat1] = STATE(226), [ts_builtin_sym_end] = ACTIONS(5), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), @@ -7424,53 +7498,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [2] = { - [sym_statement] = STATE(7), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(457), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_field_assignments] = STATE(1400), - [sym_field_assignment] = STATE(1177), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_map_entry] = STATE(1192), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(11), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(452), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_field_assignments] = STATE(1499), + [sym_field_assignment] = STATE(1130), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_map_entry] = STATE(1173), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(7), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(11), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7514,53 +7588,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [3] = { - [sym_statement] = STATE(16), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(508), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_field_assignments] = STATE(1462), - [sym_field_assignment] = STATE(1177), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_map_entry] = STATE(1197), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(6), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(440), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_field_assignments] = STATE(1693), + [sym_field_assignment] = STATE(1130), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_map_entry] = STATE(1132), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(16), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(6), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7604,53 +7678,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [4] = { - [sym_statement] = STATE(11), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(502), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_field_assignments] = STATE(1628), - [sym_field_assignment] = STATE(1177), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_map_entry] = STATE(1152), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(15), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(463), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_field_assignments] = STATE(1482), + [sym_field_assignment] = STATE(1130), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_map_entry] = STATE(1174), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(11), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(15), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7694,141 +7768,142 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [5] = { - [sym_statement] = STATE(5), - [sym_import_statement] = STATE(1367), - [sym_namespace_declaration] = STATE(1367), - [sym_let_declaration] = STATE(1367), - [sym_assignment] = STATE(1367), - [sym_function_declaration] = STATE(1367), - [sym_extern_declaration] = STATE(1367), - [sym_type_declaration] = STATE(1367), - [sym_effect_declaration] = STATE(1367), - [sym_expression_statement] = STATE(1367), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1367), - [sym_signature_declaration] = STATE(1367), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), - [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(5), - [aux_sym_doc_comment_repeat1] = STATE(224), - [ts_builtin_sym_end] = ACTIONS(81), - [sym_identifier] = ACTIONS(83), - [anon_sym_import] = ACTIONS(86), - [anon_sym_LBRACE] = ACTIONS(89), - [anon_sym_namespace] = ACTIONS(92), - [anon_sym_let] = ACTIONS(95), - [anon_sym_mut] = ACTIONS(95), - [anon_sym_fn] = ACTIONS(98), - [anon_sym_LPAREN] = ACTIONS(101), - [anon_sym_extern] = ACTIONS(104), - [anon_sym_type] = ACTIONS(107), - [anon_sym_PIPE] = ACTIONS(110), - [sym_static_stage] = ACTIONS(113), - [anon_sym_effect] = ACTIONS(116), - [anon_sym_BANG] = ACTIONS(119), - [anon_sym_LBRACK] = ACTIONS(122), - [anon_sym_match] = ACTIONS(125), - [anon_sym_if] = ACTIONS(128), - [anon_sym_handle] = ACTIONS(131), - [anon_sym_kernel] = ACTIONS(134), - [anon_sym_select] = ACTIONS(137), - [anon_sym_PLUS] = ACTIONS(119), - [anon_sym_DASH] = ACTIONS(119), - [anon_sym_await] = ACTIONS(140), - [anon_sym_spawn] = ACTIONS(143), - [anon_sym_yield] = ACTIONS(146), - [anon_sym_send] = ACTIONS(149), - [anon_sym_recv] = ACTIONS(152), - [anon_sym_perform] = ACTIONS(155), - [anon_sym_resume] = ACTIONS(158), - [anon_sym_state] = ACTIONS(161), - [anon_sym_module] = ACTIONS(164), - [anon_sym_signature] = ACTIONS(167), - [anon_sym_true] = ACTIONS(170), - [anon_sym_false] = ACTIONS(170), - [sym_float] = ACTIONS(173), - [sym_integer] = ACTIONS(176), - [sym_string] = ACTIONS(176), - [sym_interpolated_string] = ACTIONS(176), - [sym__doc_comment_line] = ACTIONS(179), + [sym_expression] = STATE(333), + [sym_match_expression] = STATE(386), + [sym_if_expression] = STATE(386), + [sym_handler_expression] = STATE(386), + [sym_kernel_expression] = STATE(386), + [sym_select_expression] = STATE(386), + [sym_ternary_expression] = STATE(386), + [sym_binary_expression] = STATE(386), + [sym_unary_expression] = STATE(386), + [sym_pipe_expression] = STATE(386), + [sym_call_expression] = STATE(386), + [sym_primary_expression] = STATE(386), + [sym_spawn_expression] = STATE(391), + [sym_yield_expression] = STATE(391), + [sym_await_call] = STATE(391), + [sym_send_call] = STATE(391), + [sym_recv_call] = STATE(391), + [sym_perform_expression] = STATE(391), + [sym_resume_expression] = STATE(391), + [sym_type_constructor] = STATE(391), + [sym_update_expression] = STATE(391), + [sym_block] = STATE(391), + [sym_object_literal] = STATE(391), + [sym_lambda_expression] = STATE(391), + [sym_literal] = STATE(391), + [sym_list_literal] = STATE(381), + [sym_map_literal] = STATE(381), + [sym_qualified_path] = STATE(329), + [sym_boolean] = STATE(381), + [sym_identifier] = ACTIONS(81), + [anon_sym_DOT] = ACTIONS(83), + [anon_sym_LBRACE] = ACTIONS(85), + [anon_sym_RBRACE] = ACTIONS(83), + [anon_sym_STAR] = ACTIONS(83), + [anon_sym_let] = ACTIONS(87), + [anon_sym_mut] = ACTIONS(87), + [anon_sym_fn] = ACTIONS(89), + [anon_sym_LT] = ACTIONS(87), + [anon_sym_GT] = ACTIONS(87), + [anon_sym_LPAREN] = ACTIONS(91), + [anon_sym_extern] = ACTIONS(87), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(93), + [sym_static_stage] = ACTIONS(87), + [anon_sym_effect] = ACTIONS(87), + [anon_sym_BANG] = ACTIONS(95), + [anon_sym_LBRACK] = ACTIONS(97), + [anon_sym_match] = ACTIONS(99), + [anon_sym_if] = ACTIONS(101), + [anon_sym_handle] = ACTIONS(103), + [anon_sym_kernel] = ACTIONS(105), + [anon_sym_select] = ACTIONS(107), + [anon_sym_QMARK] = ACTIONS(83), + [anon_sym_PIPE_PIPE] = ACTIONS(83), + [anon_sym_AMP_AMP] = ACTIONS(83), + [anon_sym_EQ_EQ] = ACTIONS(83), + [anon_sym_BANG_EQ] = ACTIONS(83), + [anon_sym_LT_EQ] = ACTIONS(83), + [anon_sym_GT_EQ] = ACTIONS(83), + [anon_sym_PLUS] = ACTIONS(109), + [anon_sym_DASH] = ACTIONS(109), + [anon_sym_SLASH] = ACTIONS(87), + [anon_sym_PERCENT] = ACTIONS(83), + [anon_sym_await] = ACTIONS(111), + [anon_sym_PIPE_GT] = ACTIONS(83), + [anon_sym_LBRACK2] = ACTIONS(83), + [anon_sym_spawn] = ACTIONS(113), + [anon_sym_yield] = ACTIONS(115), + [anon_sym_send] = ACTIONS(117), + [anon_sym_recv] = ACTIONS(119), + [anon_sym_perform] = ACTIONS(121), + [anon_sym_resume] = ACTIONS(123), + [anon_sym_LT2] = ACTIONS(87), + [anon_sym_state] = ACTIONS(87), + [anon_sym_module] = ACTIONS(87), + [anon_sym_export] = ACTIONS(87), + [anon_sym_signature] = ACTIONS(87), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(83), [sym_line_comment] = ACTIONS(3), + [sym__call_open_gap] = ACTIONS(83), }, [6] = { - [sym_statement] = STATE(5), - [sym_import_statement] = STATE(1367), - [sym_namespace_declaration] = STATE(1367), - [sym_let_declaration] = STATE(1367), - [sym_assignment] = STATE(1367), - [sym_function_declaration] = STATE(1367), - [sym_extern_declaration] = STATE(1367), - [sym_type_declaration] = STATE(1367), - [sym_effect_declaration] = STATE(1367), - [sym_expression_statement] = STATE(1367), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1367), - [sym_signature_declaration] = STATE(1367), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(504), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(5), - [aux_sym_doc_comment_repeat1] = STATE(224), - [ts_builtin_sym_end] = ACTIONS(182), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_RBRACE] = ACTIONS(131), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -7868,54 +7943,54 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [7] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(523), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(16), + [sym_import_statement] = STATE(1477), + [sym_namespace_declaration] = STATE(1477), + [sym_let_declaration] = STATE(1477), + [sym_assignment] = STATE(1477), + [sym_function_declaration] = STATE(1477), + [sym_extern_declaration] = STATE(1477), + [sym_type_declaration] = STATE(1477), + [sym_effect_declaration] = STATE(1477), + [sym_expression_statement] = STATE(1477), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1477), + [sym_signature_declaration] = STATE(1477), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(16), + [aux_sym_doc_comment_repeat1] = STATE(226), + [ts_builtin_sym_end] = ACTIONS(133), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(184), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -7956,53 +8031,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [8] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(186), + [anon_sym_RBRACE] = ACTIONS(135), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8042,54 +8117,141 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [9] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), + [sym_identifier] = ACTIONS(137), + [anon_sym_import] = ACTIONS(140), + [anon_sym_LBRACE] = ACTIONS(143), + [anon_sym_RBRACE] = ACTIONS(146), + [anon_sym_namespace] = ACTIONS(148), + [anon_sym_let] = ACTIONS(151), + [anon_sym_mut] = ACTIONS(151), + [anon_sym_fn] = ACTIONS(154), + [anon_sym_LPAREN] = ACTIONS(157), + [anon_sym_extern] = ACTIONS(160), + [anon_sym_type] = ACTIONS(163), + [anon_sym_PIPE] = ACTIONS(166), + [sym_static_stage] = ACTIONS(169), + [anon_sym_effect] = ACTIONS(172), + [anon_sym_BANG] = ACTIONS(175), + [anon_sym_LBRACK] = ACTIONS(178), + [anon_sym_match] = ACTIONS(181), + [anon_sym_if] = ACTIONS(184), + [anon_sym_handle] = ACTIONS(187), + [anon_sym_kernel] = ACTIONS(190), + [anon_sym_select] = ACTIONS(193), + [anon_sym_PLUS] = ACTIONS(175), + [anon_sym_DASH] = ACTIONS(175), + [anon_sym_await] = ACTIONS(196), + [anon_sym_spawn] = ACTIONS(199), + [anon_sym_yield] = ACTIONS(202), + [anon_sym_send] = ACTIONS(205), + [anon_sym_recv] = ACTIONS(208), + [anon_sym_perform] = ACTIONS(211), + [anon_sym_resume] = ACTIONS(214), + [anon_sym_state] = ACTIONS(217), + [anon_sym_module] = ACTIONS(220), + [anon_sym_signature] = ACTIONS(223), + [anon_sym_true] = ACTIONS(226), + [anon_sym_false] = ACTIONS(226), + [sym_float] = ACTIONS(229), + [sym_integer] = ACTIONS(232), + [sym_string] = ACTIONS(232), + [sym_interpolated_string] = ACTIONS(232), + [sym__doc_comment_line] = ACTIONS(235), + [sym_line_comment] = ACTIONS(3), + }, + [10] = { + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(489), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), + [sym_doc_comment] = STATE(20), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(188), + [anon_sym_RBRACE] = ACTIONS(238), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8128,55 +8290,55 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [10] = { - [sym_statement] = STATE(15), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(528), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [11] = { + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(507), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(15), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(190), + [anon_sym_RBRACE] = ACTIONS(240), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8215,55 +8377,55 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [11] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), + [12] = { + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), [sym_expression] = STATE(522), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(192), + [anon_sym_RBRACE] = ACTIONS(242), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8302,225 +8464,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [12] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(591), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), - [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), - [sym_identifier] = ACTIONS(83), - [anon_sym_import] = ACTIONS(86), - [anon_sym_LBRACE] = ACTIONS(89), - [anon_sym_RBRACE] = ACTIONS(81), - [anon_sym_namespace] = ACTIONS(92), - [anon_sym_let] = ACTIONS(95), - [anon_sym_mut] = ACTIONS(95), - [anon_sym_fn] = ACTIONS(98), - [anon_sym_LPAREN] = ACTIONS(101), - [anon_sym_extern] = ACTIONS(104), - [anon_sym_type] = ACTIONS(107), - [anon_sym_PIPE] = ACTIONS(110), - [sym_static_stage] = ACTIONS(113), - [anon_sym_effect] = ACTIONS(116), - [anon_sym_BANG] = ACTIONS(119), - [anon_sym_LBRACK] = ACTIONS(122), - [anon_sym_match] = ACTIONS(125), - [anon_sym_if] = ACTIONS(128), - [anon_sym_handle] = ACTIONS(131), - [anon_sym_kernel] = ACTIONS(134), - [anon_sym_select] = ACTIONS(137), - [anon_sym_PLUS] = ACTIONS(119), - [anon_sym_DASH] = ACTIONS(119), - [anon_sym_await] = ACTIONS(140), - [anon_sym_spawn] = ACTIONS(143), - [anon_sym_yield] = ACTIONS(146), - [anon_sym_send] = ACTIONS(149), - [anon_sym_recv] = ACTIONS(152), - [anon_sym_perform] = ACTIONS(155), - [anon_sym_resume] = ACTIONS(158), - [anon_sym_state] = ACTIONS(161), - [anon_sym_module] = ACTIONS(164), - [anon_sym_signature] = ACTIONS(167), - [anon_sym_true] = ACTIONS(170), - [anon_sym_false] = ACTIONS(170), - [sym_float] = ACTIONS(173), - [sym_integer] = ACTIONS(176), - [sym_string] = ACTIONS(176), - [sym_interpolated_string] = ACTIONS(176), - [sym__doc_comment_line] = ACTIONS(179), - [sym_line_comment] = ACTIONS(3), - }, [13] = { - [sym_expression] = STATE(298), - [sym_match_expression] = STATE(380), - [sym_if_expression] = STATE(380), - [sym_handler_expression] = STATE(380), - [sym_kernel_expression] = STATE(380), - [sym_select_expression] = STATE(380), - [sym_ternary_expression] = STATE(380), - [sym_binary_expression] = STATE(380), - [sym_unary_expression] = STATE(380), - [sym_pipe_expression] = STATE(380), - [sym_call_expression] = STATE(380), - [sym_primary_expression] = STATE(380), - [sym_spawn_expression] = STATE(381), - [sym_yield_expression] = STATE(381), - [sym_await_call] = STATE(381), - [sym_send_call] = STATE(381), - [sym_recv_call] = STATE(381), - [sym_perform_expression] = STATE(381), - [sym_resume_expression] = STATE(381), - [sym_type_constructor] = STATE(381), - [sym_update_expression] = STATE(381), - [sym_block] = STATE(381), - [sym_object_literal] = STATE(381), - [sym_lambda_expression] = STATE(381), - [sym_literal] = STATE(381), - [sym_list_literal] = STATE(379), - [sym_map_literal] = STATE(379), - [sym_qualified_path] = STATE(293), - [sym_boolean] = STATE(379), - [sym_identifier] = ACTIONS(194), - [anon_sym_DOT] = ACTIONS(196), - [anon_sym_LBRACE] = ACTIONS(198), - [anon_sym_RBRACE] = ACTIONS(196), - [anon_sym_STAR] = ACTIONS(196), - [anon_sym_let] = ACTIONS(200), - [anon_sym_mut] = ACTIONS(200), - [anon_sym_fn] = ACTIONS(202), - [anon_sym_LT] = ACTIONS(200), - [anon_sym_GT] = ACTIONS(200), - [anon_sym_LPAREN] = ACTIONS(204), - [anon_sym_extern] = ACTIONS(200), - [anon_sym_type] = ACTIONS(200), - [anon_sym_PIPE] = ACTIONS(206), - [sym_static_stage] = ACTIONS(200), - [anon_sym_effect] = ACTIONS(200), - [anon_sym_BANG] = ACTIONS(208), - [anon_sym_LBRACK] = ACTIONS(210), - [anon_sym_match] = ACTIONS(212), - [anon_sym_if] = ACTIONS(214), - [anon_sym_handle] = ACTIONS(216), - [anon_sym_kernel] = ACTIONS(218), - [anon_sym_select] = ACTIONS(220), - [anon_sym_QMARK] = ACTIONS(196), - [anon_sym_PIPE_PIPE] = ACTIONS(196), - [anon_sym_AMP_AMP] = ACTIONS(196), - [anon_sym_EQ_EQ] = ACTIONS(196), - [anon_sym_BANG_EQ] = ACTIONS(196), - [anon_sym_LT_EQ] = ACTIONS(196), - [anon_sym_GT_EQ] = ACTIONS(196), - [anon_sym_PLUS] = ACTIONS(222), - [anon_sym_DASH] = ACTIONS(222), - [anon_sym_SLASH] = ACTIONS(200), - [anon_sym_PERCENT] = ACTIONS(196), - [anon_sym_await] = ACTIONS(224), - [anon_sym_PIPE_GT] = ACTIONS(196), - [anon_sym_LBRACK2] = ACTIONS(196), - [anon_sym_spawn] = ACTIONS(226), - [anon_sym_yield] = ACTIONS(228), - [anon_sym_send] = ACTIONS(230), - [anon_sym_recv] = ACTIONS(232), - [anon_sym_perform] = ACTIONS(234), - [anon_sym_resume] = ACTIONS(236), - [anon_sym_state] = ACTIONS(200), - [anon_sym_module] = ACTIONS(200), - [anon_sym_export] = ACTIONS(200), - [anon_sym_signature] = ACTIONS(200), - [anon_sym_true] = ACTIONS(238), - [anon_sym_false] = ACTIONS(238), - [sym_float] = ACTIONS(240), - [sym_integer] = ACTIONS(242), - [sym_string] = ACTIONS(242), - [sym_interpolated_string] = ACTIONS(242), - [sym__doc_comment_line] = ACTIONS(196), - [sym_line_comment] = ACTIONS(3), - [sym__call_open_gap] = ACTIONS(196), - }, - [14] = { - [sym_statement] = STATE(17), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(527), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(519), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(17), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8563,51 +8551,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [15] = { + [14] = { [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(530), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(511), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8650,51 +8638,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [16] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(534), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [15] = { + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(521), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8737,51 +8725,138 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, + [16] = { + [sym_statement] = STATE(16), + [sym_import_statement] = STATE(1477), + [sym_namespace_declaration] = STATE(1477), + [sym_let_declaration] = STATE(1477), + [sym_assignment] = STATE(1477), + [sym_function_declaration] = STATE(1477), + [sym_extern_declaration] = STATE(1477), + [sym_type_declaration] = STATE(1477), + [sym_effect_declaration] = STATE(1477), + [sym_expression_statement] = STATE(1477), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1477), + [sym_signature_declaration] = STATE(1477), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), + [sym_doc_comment] = STATE(20), + [aux_sym_source_file_repeat1] = STATE(16), + [aux_sym_doc_comment_repeat1] = STATE(226), + [ts_builtin_sym_end] = ACTIONS(146), + [sym_identifier] = ACTIONS(137), + [anon_sym_import] = ACTIONS(140), + [anon_sym_LBRACE] = ACTIONS(143), + [anon_sym_namespace] = ACTIONS(148), + [anon_sym_let] = ACTIONS(151), + [anon_sym_mut] = ACTIONS(151), + [anon_sym_fn] = ACTIONS(154), + [anon_sym_LPAREN] = ACTIONS(157), + [anon_sym_extern] = ACTIONS(160), + [anon_sym_type] = ACTIONS(163), + [anon_sym_PIPE] = ACTIONS(166), + [sym_static_stage] = ACTIONS(169), + [anon_sym_effect] = ACTIONS(172), + [anon_sym_BANG] = ACTIONS(175), + [anon_sym_LBRACK] = ACTIONS(178), + [anon_sym_match] = ACTIONS(181), + [anon_sym_if] = ACTIONS(184), + [anon_sym_handle] = ACTIONS(187), + [anon_sym_kernel] = ACTIONS(190), + [anon_sym_select] = ACTIONS(193), + [anon_sym_PLUS] = ACTIONS(175), + [anon_sym_DASH] = ACTIONS(175), + [anon_sym_await] = ACTIONS(196), + [anon_sym_spawn] = ACTIONS(199), + [anon_sym_yield] = ACTIONS(202), + [anon_sym_send] = ACTIONS(205), + [anon_sym_recv] = ACTIONS(208), + [anon_sym_perform] = ACTIONS(211), + [anon_sym_resume] = ACTIONS(214), + [anon_sym_state] = ACTIONS(217), + [anon_sym_module] = ACTIONS(220), + [anon_sym_signature] = ACTIONS(223), + [anon_sym_true] = ACTIONS(226), + [anon_sym_false] = ACTIONS(226), + [sym_float] = ACTIONS(229), + [sym_integer] = ACTIONS(232), + [sym_string] = ACTIONS(232), + [sym_interpolated_string] = ACTIONS(232), + [sym__doc_comment_line] = ACTIONS(235), + [sym_line_comment] = ACTIONS(3), + }, [17] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1625), - [sym_namespace_declaration] = STATE(1625), - [sym_let_declaration] = STATE(1625), - [sym_assignment] = STATE(1625), - [sym_function_declaration] = STATE(1625), - [sym_extern_declaration] = STATE(1625), - [sym_type_declaration] = STATE(1625), - [sym_effect_declaration] = STATE(1625), - [sym_expression_statement] = STATE(1625), - [sym_expression] = STATE(535), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_module_declaration] = STATE(1625), - [sym_signature_declaration] = STATE(1625), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_statement] = STATE(8), + [sym_import_statement] = STATE(1688), + [sym_namespace_declaration] = STATE(1688), + [sym_let_declaration] = STATE(1688), + [sym_assignment] = STATE(1688), + [sym_function_declaration] = STATE(1688), + [sym_extern_declaration] = STATE(1688), + [sym_type_declaration] = STATE(1688), + [sym_effect_declaration] = STATE(1688), + [sym_expression_statement] = STATE(1688), + [sym_expression] = STATE(533), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_module_declaration] = STATE(1688), + [sym_signature_declaration] = STATE(1688), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(224), + [aux_sym_source_file_repeat1] = STATE(8), + [aux_sym_doc_comment_repeat1] = STATE(226), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8825,78 +8900,79 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [18] = { - [sym_expression] = STATE(238), - [sym_match_expression] = STATE(240), - [sym_if_expression] = STATE(240), - [sym_handler_expression] = STATE(240), - [sym_kernel_expression] = STATE(240), - [sym_select_expression] = STATE(240), - [sym_ternary_expression] = STATE(240), - [sym_binary_expression] = STATE(240), - [sym_unary_expression] = STATE(240), - [sym_pipe_expression] = STATE(240), - [sym_call_expression] = STATE(240), - [sym_primary_expression] = STATE(240), - [sym_spawn_expression] = STATE(249), - [sym_yield_expression] = STATE(249), - [sym_await_call] = STATE(249), - [sym_send_call] = STATE(249), - [sym_recv_call] = STATE(249), - [sym_perform_expression] = STATE(249), - [sym_resume_expression] = STATE(249), - [sym_type_constructor] = STATE(249), - [sym_update_expression] = STATE(249), - [sym_block] = STATE(249), - [sym_object_literal] = STATE(249), - [sym_lambda_expression] = STATE(249), - [sym_literal] = STATE(249), - [sym_list_literal] = STATE(250), - [sym_map_literal] = STATE(250), - [sym_qualified_path] = STATE(230), - [sym_boolean] = STATE(250), + [sym_expression] = STATE(245), + [sym_match_expression] = STATE(258), + [sym_if_expression] = STATE(258), + [sym_handler_expression] = STATE(258), + [sym_kernel_expression] = STATE(258), + [sym_select_expression] = STATE(258), + [sym_ternary_expression] = STATE(258), + [sym_binary_expression] = STATE(258), + [sym_unary_expression] = STATE(258), + [sym_pipe_expression] = STATE(258), + [sym_call_expression] = STATE(258), + [sym_primary_expression] = STATE(258), + [sym_spawn_expression] = STATE(259), + [sym_yield_expression] = STATE(259), + [sym_await_call] = STATE(259), + [sym_send_call] = STATE(259), + [sym_recv_call] = STATE(259), + [sym_perform_expression] = STATE(259), + [sym_resume_expression] = STATE(259), + [sym_type_constructor] = STATE(259), + [sym_update_expression] = STATE(259), + [sym_block] = STATE(259), + [sym_object_literal] = STATE(259), + [sym_lambda_expression] = STATE(259), + [sym_literal] = STATE(259), + [sym_list_literal] = STATE(273), + [sym_map_literal] = STATE(273), + [sym_qualified_path] = STATE(250), + [sym_boolean] = STATE(273), [sym_identifier] = ACTIONS(252), - [anon_sym_DOT] = ACTIONS(196), + [anon_sym_DOT] = ACTIONS(83), [anon_sym_LBRACE] = ACTIONS(254), - [anon_sym_RBRACE] = ACTIONS(196), - [anon_sym_STAR] = ACTIONS(196), - [anon_sym_COMMA] = ACTIONS(196), - [anon_sym_COLON] = ACTIONS(196), + [anon_sym_RBRACE] = ACTIONS(83), + [anon_sym_STAR] = ACTIONS(83), + [anon_sym_COMMA] = ACTIONS(83), + [anon_sym_COLON] = ACTIONS(83), [anon_sym_fn] = ACTIONS(256), - [anon_sym_LT] = ACTIONS(200), - [anon_sym_GT] = ACTIONS(200), + [anon_sym_LT] = ACTIONS(87), + [anon_sym_GT] = ACTIONS(87), [anon_sym_LPAREN] = ACTIONS(258), - [anon_sym_RPAREN] = ACTIONS(196), - [anon_sym__] = ACTIONS(200), - [anon_sym_in] = ACTIONS(200), + [anon_sym_RPAREN] = ACTIONS(83), + [anon_sym__] = ACTIONS(87), + [anon_sym_in] = ACTIONS(87), [anon_sym_PIPE] = ACTIONS(260), [anon_sym_BANG] = ACTIONS(262), [anon_sym_LBRACK] = ACTIONS(264), - [anon_sym_RBRACK] = ACTIONS(196), + [anon_sym_RBRACK] = ACTIONS(83), [anon_sym_match] = ACTIONS(266), [anon_sym_if] = ACTIONS(268), [anon_sym_handle] = ACTIONS(270), [anon_sym_kernel] = ACTIONS(272), [anon_sym_select] = ACTIONS(274), - [anon_sym_QMARK] = ACTIONS(196), - [anon_sym_PIPE_PIPE] = ACTIONS(196), - [anon_sym_AMP_AMP] = ACTIONS(196), - [anon_sym_EQ_EQ] = ACTIONS(196), - [anon_sym_BANG_EQ] = ACTIONS(196), - [anon_sym_LT_EQ] = ACTIONS(196), - [anon_sym_GT_EQ] = ACTIONS(196), + [anon_sym_QMARK] = ACTIONS(83), + [anon_sym_PIPE_PIPE] = ACTIONS(83), + [anon_sym_AMP_AMP] = ACTIONS(83), + [anon_sym_EQ_EQ] = ACTIONS(83), + [anon_sym_BANG_EQ] = ACTIONS(83), + [anon_sym_LT_EQ] = ACTIONS(83), + [anon_sym_GT_EQ] = ACTIONS(83), [anon_sym_PLUS] = ACTIONS(276), [anon_sym_DASH] = ACTIONS(276), - [anon_sym_SLASH] = ACTIONS(200), - [anon_sym_PERCENT] = ACTIONS(196), + [anon_sym_SLASH] = ACTIONS(87), + [anon_sym_PERCENT] = ACTIONS(83), [anon_sym_await] = ACTIONS(278), - [anon_sym_PIPE_GT] = ACTIONS(196), - [anon_sym_LBRACK2] = ACTIONS(196), + [anon_sym_PIPE_GT] = ACTIONS(83), + [anon_sym_LBRACK2] = ACTIONS(83), [anon_sym_spawn] = ACTIONS(280), [anon_sym_yield] = ACTIONS(282), [anon_sym_send] = ACTIONS(284), [anon_sym_recv] = ACTIONS(286), [anon_sym_perform] = ACTIONS(288), [anon_sym_resume] = ACTIONS(290), + [anon_sym_LT2] = ACTIONS(87), [anon_sym_true] = ACTIONS(292), [anon_sym_false] = ACTIONS(292), [sym_float] = ACTIONS(294), @@ -8904,47 +8980,47 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_string] = ACTIONS(296), [sym_interpolated_string] = ACTIONS(296), [sym_line_comment] = ACTIONS(298), - [sym__call_open_gap] = ACTIONS(196), + [sym__call_open_gap] = ACTIONS(83), }, [19] = { - [sym_expression] = STATE(495), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_expression] = STATE(447), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_identifier] = ACTIONS(300), - [anon_sym_DOT] = ACTIONS(196), + [anon_sym_DOT] = ACTIONS(83), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(196), - [anon_sym_STAR] = ACTIONS(196), - [anon_sym_COLON] = ACTIONS(196), + [anon_sym_RBRACE] = ACTIONS(83), + [anon_sym_STAR] = ACTIONS(83), + [anon_sym_COLON] = ACTIONS(83), [anon_sym_fn] = ACTIONS(302), - [anon_sym_LT] = ACTIONS(200), - [anon_sym_GT] = ACTIONS(200), + [anon_sym_LT] = ACTIONS(87), + [anon_sym_GT] = ACTIONS(87), [anon_sym_LPAREN] = ACTIONS(19), [anon_sym_PIPE] = ACTIONS(304), [anon_sym_BANG] = ACTIONS(306), @@ -8954,26 +9030,27 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_handle] = ACTIONS(39), [anon_sym_kernel] = ACTIONS(41), [anon_sym_select] = ACTIONS(43), - [anon_sym_QMARK] = ACTIONS(196), - [anon_sym_PIPE_PIPE] = ACTIONS(196), - [anon_sym_AMP_AMP] = ACTIONS(196), - [anon_sym_EQ_EQ] = ACTIONS(196), - [anon_sym_BANG_EQ] = ACTIONS(196), - [anon_sym_LT_EQ] = ACTIONS(196), - [anon_sym_GT_EQ] = ACTIONS(196), + [anon_sym_QMARK] = ACTIONS(83), + [anon_sym_PIPE_PIPE] = ACTIONS(83), + [anon_sym_AMP_AMP] = ACTIONS(83), + [anon_sym_EQ_EQ] = ACTIONS(83), + [anon_sym_BANG_EQ] = ACTIONS(83), + [anon_sym_LT_EQ] = ACTIONS(83), + [anon_sym_GT_EQ] = ACTIONS(83), [anon_sym_PLUS] = ACTIONS(31), [anon_sym_DASH] = ACTIONS(31), - [anon_sym_SLASH] = ACTIONS(200), - [anon_sym_PERCENT] = ACTIONS(196), + [anon_sym_SLASH] = ACTIONS(87), + [anon_sym_PERCENT] = ACTIONS(83), [anon_sym_await] = ACTIONS(45), - [anon_sym_PIPE_GT] = ACTIONS(196), - [anon_sym_LBRACK2] = ACTIONS(196), + [anon_sym_PIPE_GT] = ACTIONS(83), + [anon_sym_LBRACK2] = ACTIONS(83), [anon_sym_spawn] = ACTIONS(47), [anon_sym_yield] = ACTIONS(49), [anon_sym_send] = ACTIONS(51), [anon_sym_recv] = ACTIONS(53), [anon_sym_perform] = ACTIONS(55), [anon_sym_resume] = ACTIONS(57), + [anon_sym_LT2] = ACTIONS(87), [anon_sym_true] = ACTIONS(65), [anon_sym_false] = ACTIONS(65), [sym_float] = ACTIONS(67), @@ -8981,39 +9058,39 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_string] = ACTIONS(69), [sym_interpolated_string] = ACTIONS(69), [sym_line_comment] = ACTIONS(298), - [sym__call_open_gap] = ACTIONS(196), - [sym__statement_break] = ACTIONS(196), + [sym__call_open_gap] = ACTIONS(83), + [sym__statement_break] = ACTIONS(83), }, [20] = { - [sym_expression] = STATE(565), - [sym_match_expression] = STATE(456), - [sym_if_expression] = STATE(456), - [sym_handler_expression] = STATE(456), - [sym_kernel_expression] = STATE(456), - [sym_select_expression] = STATE(456), - [sym_ternary_expression] = STATE(456), - [sym_binary_expression] = STATE(456), - [sym_unary_expression] = STATE(456), - [sym_pipe_expression] = STATE(456), - [sym_call_expression] = STATE(456), - [sym_primary_expression] = STATE(456), - [sym_spawn_expression] = STATE(458), - [sym_yield_expression] = STATE(458), - [sym_await_call] = STATE(458), - [sym_send_call] = STATE(458), - [sym_recv_call] = STATE(458), - [sym_perform_expression] = STATE(458), - [sym_resume_expression] = STATE(458), - [sym_type_constructor] = STATE(458), - [sym_update_expression] = STATE(458), - [sym_block] = STATE(458), - [sym_object_literal] = STATE(458), - [sym_lambda_expression] = STATE(458), - [sym_literal] = STATE(458), - [sym_list_literal] = STATE(489), - [sym_map_literal] = STATE(489), - [sym_qualified_path] = STATE(433), - [sym_boolean] = STATE(489), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(473), + [sym_if_expression] = STATE(473), + [sym_handler_expression] = STATE(473), + [sym_kernel_expression] = STATE(473), + [sym_select_expression] = STATE(473), + [sym_ternary_expression] = STATE(473), + [sym_binary_expression] = STATE(473), + [sym_unary_expression] = STATE(473), + [sym_pipe_expression] = STATE(473), + [sym_call_expression] = STATE(473), + [sym_primary_expression] = STATE(473), + [sym_spawn_expression] = STATE(493), + [sym_yield_expression] = STATE(493), + [sym_await_call] = STATE(493), + [sym_send_call] = STATE(493), + [sym_recv_call] = STATE(493), + [sym_perform_expression] = STATE(493), + [sym_resume_expression] = STATE(493), + [sym_type_constructor] = STATE(493), + [sym_update_expression] = STATE(493), + [sym_block] = STATE(493), + [sym_object_literal] = STATE(493), + [sym_lambda_expression] = STATE(493), + [sym_literal] = STATE(493), + [sym_list_literal] = STATE(477), + [sym_map_literal] = STATE(477), + [sym_qualified_path] = STATE(460), + [sym_boolean] = STATE(477), [sym_identifier] = ACTIONS(300), [anon_sym_LBRACE] = ACTIONS(11), [anon_sym_namespace] = ACTIONS(310), @@ -9099,16 +9176,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1495), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1460), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9120,11 +9197,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9136,7 +9213,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9193,15 +9270,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(338), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1491), 1, + STATE(1443), 1, sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9214,11 +9291,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9230,7 +9307,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9287,16 +9364,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(340), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1425), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1493), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9308,11 +9385,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9324,7 +9401,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9381,16 +9458,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(342), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1362), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1679), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9402,11 +9479,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9418,7 +9495,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9475,15 +9552,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(344), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1453), 1, + STATE(1425), 1, sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9496,11 +9573,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9512,7 +9589,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9569,15 +9646,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(346), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1405), 1, + STATE(1382), 1, sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9590,11 +9667,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9606,7 +9683,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9663,16 +9740,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(348), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1638), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1516), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9684,11 +9761,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9700,7 +9777,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9757,16 +9834,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(350), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1505), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1517), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9778,11 +9855,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9794,7 +9871,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9851,16 +9928,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(352), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(469), 1, + STATE(444), 1, sym_expression, - STATE(1242), 1, + STATE(1240), 1, sym_named_argument, - STATE(1509), 1, - sym_argument_list, - STATE(1659), 1, + STATE(1449), 1, sym_named_argument_list, + STATE(1527), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9872,11 +9949,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9888,7 +9965,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9902,9 +9979,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1134] = 29, - ACTIONS(252), 1, - sym_identifier, + [1134] = 32, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -9939,104 +10014,24 @@ static const uint16_t ts_small_parse_table[] = { sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - ACTIONS(354), 1, - anon_sym_RBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(475), 1, - sym_expression, - ACTIONS(292), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(276), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(296), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(250), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(240), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(249), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1251] = 29, - ACTIONS(252), 1, + ACTIONS(330), 1, sym_identifier, - ACTIONS(254), 1, - anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, - anon_sym_match, - ACTIONS(268), 1, - anon_sym_if, - ACTIONS(270), 1, - anon_sym_handle, - ACTIONS(272), 1, - anon_sym_kernel, - ACTIONS(274), 1, - anon_sym_select, - ACTIONS(278), 1, - anon_sym_await, - ACTIONS(280), 1, - anon_sym_spawn, - ACTIONS(282), 1, - anon_sym_yield, - ACTIONS(284), 1, - anon_sym_send, - ACTIONS(286), 1, - anon_sym_recv, - ACTIONS(288), 1, - anon_sym_perform, - ACTIONS(290), 1, - anon_sym_resume, - ACTIONS(294), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(334), 1, anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(356), 1, + ACTIONS(354), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(578), 1, + STATE(444), 1, sym_expression, + STATE(1240), 1, + sym_named_argument, + STATE(1449), 1, + sym_named_argument_list, + STATE(1531), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10048,11 +10043,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10064,7 +10059,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10078,9 +10073,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1368] = 29, - ACTIONS(252), 1, - sym_identifier, + [1260] = 32, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10115,104 +10108,24 @@ static const uint16_t ts_small_parse_table[] = { sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - ACTIONS(358), 1, - anon_sym_COLON, - STATE(230), 1, - sym_qualified_path, - STATE(538), 1, - sym_expression, - ACTIONS(292), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(276), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(296), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(250), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(240), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(249), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1485] = 29, - ACTIONS(252), 1, + ACTIONS(330), 1, sym_identifier, - ACTIONS(254), 1, - anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, - anon_sym_match, - ACTIONS(268), 1, - anon_sym_if, - ACTIONS(270), 1, - anon_sym_handle, - ACTIONS(272), 1, - anon_sym_kernel, - ACTIONS(274), 1, - anon_sym_select, - ACTIONS(278), 1, - anon_sym_await, - ACTIONS(280), 1, - anon_sym_spawn, - ACTIONS(282), 1, - anon_sym_yield, - ACTIONS(284), 1, - anon_sym_send, - ACTIONS(286), 1, - anon_sym_recv, - ACTIONS(288), 1, - anon_sym_perform, - ACTIONS(290), 1, - anon_sym_resume, - ACTIONS(294), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(334), 1, anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(360), 1, - anon_sym_COLON, - STATE(230), 1, + ACTIONS(356), 1, + anon_sym_RPAREN, + STATE(250), 1, sym_qualified_path, - STATE(580), 1, + STATE(444), 1, sym_expression, + STATE(1240), 1, + sym_named_argument, + STATE(1445), 1, + sym_argument_list, + STATE(1449), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10224,11 +10137,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10240,7 +10153,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10254,9 +10167,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1602] = 29, - ACTIONS(252), 1, - sym_identifier, + [1386] = 32, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10291,16 +10202,24 @@ static const uint16_t ts_small_parse_table[] = { sym_float, ACTIONS(298), 1, sym_line_comment, + ACTIONS(330), 1, + sym_identifier, ACTIONS(334), 1, anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(362), 1, - anon_sym_RBRACK, - STATE(230), 1, + ACTIONS(358), 1, + anon_sym_RPAREN, + STATE(250), 1, sym_qualified_path, - STATE(509), 1, + STATE(444), 1, sym_expression, + STATE(1240), 1, + sym_named_argument, + STATE(1381), 1, + sym_argument_list, + STATE(1449), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10312,11 +10231,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10328,7 +10247,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10342,7 +10261,9 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1719] = 29, + [1512] = 29, + ACTIONS(252), 1, + sym_identifier, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10381,14 +10302,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(364), 1, - sym_identifier, - STATE(230), 1, + ACTIONS(360), 1, + anon_sym_RPAREN, + STATE(250), 1, sym_qualified_path, - STATE(541), 1, + STATE(575), 1, sym_expression, - STATE(1700), 1, - sym_field_pattern, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10400,11 +10319,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10416,7 +10335,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10430,7 +10349,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1836] = 29, + [1629] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -10471,11 +10390,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - anon_sym_RPAREN, - STATE(230), 1, + ACTIONS(362), 1, + anon_sym_RBRACK, + STATE(250), 1, sym_qualified_path, - STATE(596), 1, + STATE(457), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10488,11 +10407,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10504,7 +10423,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10518,7 +10437,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1953] = 29, + [1746] = 29, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10559,11 +10478,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(364), 1, sym_identifier, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(613), 1, + STATE(606), 1, sym_expression, - STATE(1700), 1, + STATE(1360), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -10576,11 +10495,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10592,7 +10511,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10606,7 +10525,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2070] = 29, + [1863] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -10647,11 +10566,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(368), 1, + ACTIONS(366), 1, anon_sym_COLON, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(597), 1, + STATE(577), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10664,11 +10583,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10680,7 +10599,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10694,7 +10613,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2187] = 29, + [1980] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -10735,11 +10654,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(370), 1, + ACTIONS(368), 1, anon_sym_RPAREN, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(586), 1, + STATE(556), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10752,11 +10671,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10768,7 +10687,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10782,7 +10701,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2304] = 29, + [2097] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -10823,11 +10742,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(570), 1, + STATE(571), 1, sym_expression, - STATE(1313), 1, + STATE(1278), 1, sym_map_entry, ACTIONS(292), 2, anon_sym_true, @@ -10840,11 +10759,99 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [2214] = 29, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + ACTIONS(370), 1, + anon_sym_COLON, + STATE(250), 1, + sym_qualified_path, + STATE(589), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10856,7 +10863,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10870,7 +10877,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2421] = 29, + [2331] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -10913,9 +10920,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(372), 1, anon_sym_RBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(503), 1, + STATE(467), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10928,11 +10935,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10944,7 +10951,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10958,7 +10965,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2538] = 29, + [2448] = 29, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10999,11 +11006,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(364), 1, sym_identifier, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(610), 1, + STATE(542), 1, sym_expression, - STATE(1700), 1, + STATE(1360), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -11016,11 +11023,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11032,7 +11039,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11046,7 +11053,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2655] = 28, + [2565] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -11087,9 +11094,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(374), 1, + anon_sym_RPAREN, + STATE(250), 1, sym_qualified_path, - STATE(603), 1, + STATE(546), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11102,11 +11111,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11118,7 +11127,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11132,7 +11141,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2769] = 28, + [2682] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -11173,9 +11182,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(376), 1, + anon_sym_RBRACK, + STATE(250), 1, sym_qualified_path, - STATE(529), 1, + STATE(464), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11188,11 +11199,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11204,7 +11215,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11218,9 +11229,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2883] = 28, - ACTIONS(252), 1, - sym_identifier, + [2799] = 29, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -11259,10 +11268,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(364), 1, + sym_identifier, + STATE(250), 1, sym_qualified_path, - STATE(387), 1, + STATE(603), 1, sym_expression, + STATE(1360), 1, + sym_field_pattern, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -11274,11 +11287,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11290,7 +11303,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11304,7 +11317,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2997] = 28, + [2916] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -11345,9 +11358,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(378), 1, + anon_sym_COLON, + STATE(250), 1, sym_qualified_path, - STATE(547), 1, + STATE(548), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11360,11 +11375,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11376,7 +11391,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11390,67 +11405,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3111] = 28, - ACTIONS(11), 1, + [3033] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, sym_qualified_path, - STATE(486), 1, + STATE(560), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11462,7 +11477,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11476,67 +11491,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3225] = 28, - ACTIONS(11), 1, + [3147] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, sym_qualified_path, - STATE(553), 1, + STATE(562), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11548,7 +11563,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11562,7 +11577,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3339] = 28, + [3261] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -11603,10 +11618,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(554), 1, + STATE(455), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -11618,11 +11633,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11634,7 +11649,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11648,7 +11663,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3453] = 28, + [3375] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -11689,9 +11704,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(487), 1, + STATE(528), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -11704,11 +11719,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11720,7 +11735,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11734,7 +11749,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3567] = 28, + [3489] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -11775,9 +11790,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(490), 1, + STATE(554), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -11790,11 +11805,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11806,7 +11821,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11820,7 +11835,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3681] = 28, + [3603] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -11861,10 +11876,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(555), 1, + STATE(443), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -11876,11 +11891,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11892,7 +11907,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11906,7 +11921,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3795] = 28, + [3717] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -11947,9 +11962,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(388), 1, + STATE(530), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11962,11 +11977,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11978,7 +11993,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11992,7 +12007,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3909] = 28, + [3831] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12033,9 +12048,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(491), 1, + STATE(588), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12048,11 +12063,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12064,7 +12079,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12078,7 +12093,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4023] = 28, + [3945] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -12119,9 +12134,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(519), 1, + STATE(394), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12134,11 +12149,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12150,7 +12165,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12164,7 +12179,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4137] = 28, + [4059] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12205,10 +12220,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(492), 1, + STATE(446), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12220,11 +12235,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12236,7 +12251,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12250,7 +12265,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4251] = 28, + [4173] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -12291,9 +12306,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(521), 1, + STATE(498), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12306,11 +12321,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12322,7 +12337,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12336,7 +12351,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4365] = 28, + [4287] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12377,10 +12392,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(606), 1, + STATE(450), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12392,11 +12407,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12408,7 +12423,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12422,7 +12437,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4479] = 28, + [4401] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -12463,9 +12478,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(525), 1, + STATE(502), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12478,11 +12493,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12494,7 +12509,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12508,7 +12523,93 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4593] = 28, + [4515] = 28, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, + anon_sym_match, + ACTIONS(37), 1, + anon_sym_if, + ACTIONS(39), 1, + anon_sym_handle, + ACTIONS(41), 1, + anon_sym_kernel, + ACTIONS(43), 1, + anon_sym_select, + ACTIONS(45), 1, + anon_sym_await, + ACTIONS(47), 1, + anon_sym_spawn, + ACTIONS(49), 1, + anon_sym_yield, + ACTIONS(51), 1, + anon_sym_send, + ACTIONS(53), 1, + anon_sym_recv, + ACTIONS(55), 1, + anon_sym_perform, + ACTIONS(57), 1, + anon_sym_resume, + ACTIONS(67), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(441), 1, + sym_expression, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(31), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(69), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(477), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(473), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(493), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [4629] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -12549,9 +12650,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(564), 1, + STATE(518), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12564,11 +12665,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12580,7 +12681,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12594,7 +12695,93 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4707] = 28, + [4743] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(576), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [4857] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12635,10 +12822,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(496), 1, + STATE(451), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12650,11 +12837,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12666,7 +12853,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12680,7 +12867,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4821] = 28, + [4971] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12721,9 +12908,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(568), 1, + STATE(534), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12736,11 +12923,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12752,7 +12939,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12766,7 +12953,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4935] = 28, + [5085] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12807,9 +12994,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(569), 1, + STATE(541), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12822,11 +13009,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12838,7 +13025,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12852,7 +13039,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5049] = 28, + [5199] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -12893,10 +13080,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(499), 1, + STATE(458), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12908,11 +13095,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12924,7 +13111,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12938,67 +13125,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5163] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [5313] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(627), 1, + STATE(550), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13010,7 +13197,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13024,7 +13211,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5277] = 28, + [5427] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13065,9 +13252,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(582), 1, + STATE(536), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13080,11 +13267,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13096,7 +13283,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13110,7 +13297,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5391] = 28, + [5541] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13151,9 +13338,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(583), 1, + STATE(537), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13166,11 +13353,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13182,7 +13369,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13196,7 +13383,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5505] = 28, + [5655] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13237,10 +13424,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(507), 1, + STATE(445), 1, sym_expression, + STATE(460), 1, + sym_qualified_path, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -13252,11 +13439,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13268,7 +13455,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13282,7 +13469,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5619] = 28, + [5769] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13323,9 +13510,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(588), 1, + STATE(552), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13338,11 +13525,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13354,7 +13541,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13368,7 +13555,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5733] = 28, + [5883] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13409,9 +13596,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(590), 1, + STATE(564), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13424,11 +13611,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13440,7 +13627,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13454,7 +13641,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5847] = 28, + [5997] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -13495,9 +13682,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(601), 1, + STATE(566), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -13510,11 +13697,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13526,7 +13713,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13540,7 +13727,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5961] = 28, + [6111] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13581,9 +13768,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(440), 1, + STATE(462), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13596,11 +13783,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13612,7 +13799,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13626,7 +13813,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6075] = 28, + [6225] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13667,9 +13854,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(607), 1, + STATE(569), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13682,11 +13869,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13698,7 +13885,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13712,7 +13899,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6189] = 28, + [6339] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13753,9 +13940,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(608), 1, + STATE(570), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13768,11 +13955,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13784,7 +13971,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13798,7 +13985,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6303] = 28, + [6453] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13839,9 +14026,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(611), 1, + STATE(579), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13854,11 +14041,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13870,7 +14057,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13884,7 +14071,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6417] = 28, + [6567] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -13925,9 +14112,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(539), 1, + STATE(586), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13940,11 +14127,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13956,7 +14143,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13970,7 +14157,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6531] = 28, + [6681] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14011,9 +14198,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(571), 1, + STATE(587), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14026,11 +14213,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14042,7 +14229,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14056,7 +14243,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6645] = 29, + [6795] = 29, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -14097,11 +14284,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(514), 1, + STATE(590), 1, sym_call_expression, - STATE(621), 1, + STATE(614), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -14114,11 +14301,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 10, + STATE(258), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14129,7 +14316,7 @@ static const uint16_t ts_small_parse_table[] = { sym_unary_expression, sym_pipe_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14143,7 +14330,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6761] = 28, + [6911] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14184,9 +14371,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(542), 1, + STATE(592), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14199,11 +14386,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14215,7 +14402,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14229,7 +14416,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6875] = 28, + [7025] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14270,9 +14457,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(593), 1, + STATE(595), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14285,11 +14472,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14301,7 +14488,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14315,7 +14502,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6989] = 28, + [7139] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14356,9 +14543,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(604), 1, + STATE(597), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14371,11 +14558,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14387,7 +14574,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14401,7 +14588,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7103] = 28, + [7253] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14442,9 +14629,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(605), 1, + STATE(598), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14457,11 +14644,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14473,7 +14660,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14487,7 +14674,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7217] = 28, + [7367] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14528,9 +14715,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(552), 1, + STATE(600), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14543,11 +14730,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14559,7 +14746,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14573,7 +14760,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7331] = 28, + [7481] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14614,9 +14801,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(563), 1, + STATE(601), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14629,11 +14816,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14645,7 +14832,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14659,7 +14846,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7445] = 28, + [7595] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14700,9 +14887,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(572), 1, + STATE(607), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14715,11 +14902,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14731,7 +14918,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14745,7 +14932,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7559] = 28, + [7709] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14786,95 +14973,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(574), 1, - sym_expression, - ACTIONS(65), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(31), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(69), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(489), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(456), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(458), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [7673] = 28, - ACTIONS(11), 1, - anon_sym_LBRACE, - ACTIONS(19), 1, - anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_match, - ACTIONS(37), 1, - anon_sym_if, - ACTIONS(39), 1, - anon_sym_handle, - ACTIONS(41), 1, - anon_sym_kernel, - ACTIONS(43), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_await, - ACTIONS(47), 1, - anon_sym_spawn, - ACTIONS(49), 1, - anon_sym_yield, - ACTIONS(51), 1, - anon_sym_send, - ACTIONS(53), 1, - anon_sym_recv, - ACTIONS(55), 1, - anon_sym_perform, - ACTIONS(57), 1, - anon_sym_resume, - ACTIONS(67), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(599), 1, + STATE(608), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14887,11 +14988,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14903,7 +15004,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14917,7 +15018,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7787] = 28, + [7823] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -14958,9 +15059,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(540), 1, + STATE(609), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14973,11 +15074,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14989,7 +15090,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15003,7 +15104,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7901] = 28, + [7937] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15044,9 +15145,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(543), 1, + STATE(527), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15059,11 +15160,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15075,7 +15176,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15089,7 +15190,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8015] = 28, + [8051] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15130,9 +15231,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(544), 1, + STATE(567), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15145,11 +15246,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15161,7 +15262,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15175,7 +15276,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8129] = 28, + [8165] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15216,9 +15317,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(548), 1, + STATE(532), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15231,11 +15332,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15247,7 +15348,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15261,7 +15362,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8243] = 28, + [8279] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15302,9 +15403,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(549), 1, + STATE(535), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15317,11 +15418,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15333,7 +15434,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15347,7 +15448,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8357] = 28, + [8393] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15388,9 +15489,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(550), 1, + STATE(555), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15403,11 +15504,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15419,7 +15520,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15433,7 +15534,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8471] = 28, + [8507] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15474,9 +15575,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(551), 1, + STATE(559), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15489,11 +15590,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15505,7 +15606,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15519,7 +15620,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8585] = 28, + [8621] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15560,9 +15661,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(556), 1, + STATE(596), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15575,11 +15676,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15591,7 +15692,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15605,7 +15706,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8699] = 28, + [8735] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15646,9 +15747,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(557), 1, + STATE(529), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15661,11 +15762,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15677,7 +15778,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15691,7 +15792,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8813] = 28, + [8849] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15732,9 +15833,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(559), 1, + STATE(531), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15747,11 +15848,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15763,7 +15864,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15777,7 +15878,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8927] = 28, + [8963] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15818,9 +15919,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(562), 1, + STATE(557), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15833,11 +15934,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15849,7 +15950,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15863,7 +15964,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9041] = 28, + [9077] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15904,9 +16005,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(566), 1, + STATE(565), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15919,11 +16020,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15935,7 +16036,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15949,7 +16050,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9155] = 28, + [9191] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -15990,9 +16091,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(439), 1, + STATE(591), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16005,11 +16106,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16021,7 +16122,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16035,7 +16136,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9269] = 28, + [9305] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -16076,96 +16177,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(252), 1, + STATE(236), 1, sym_expression, - ACTIONS(292), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(276), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(296), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(250), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(240), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(249), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [9383] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, - anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, - anon_sym_match, - ACTIONS(268), 1, - anon_sym_if, - ACTIONS(270), 1, - anon_sym_handle, - ACTIONS(272), 1, - anon_sym_kernel, - ACTIONS(274), 1, - anon_sym_select, - ACTIONS(278), 1, - anon_sym_await, - ACTIONS(280), 1, - anon_sym_spawn, - ACTIONS(282), 1, - anon_sym_yield, - ACTIONS(284), 1, - anon_sym_send, - ACTIONS(286), 1, - anon_sym_recv, - ACTIONS(288), 1, - anon_sym_perform, - ACTIONS(290), 1, - anon_sym_resume, - ACTIONS(294), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(253), 1, - sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16177,11 +16192,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16193,7 +16208,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16207,7 +16222,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9497] = 28, + [9419] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -16248,96 +16263,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(254), 1, + STATE(235), 1, sym_expression, - ACTIONS(292), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(276), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(296), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(250), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(240), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(249), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [9611] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, - anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, - anon_sym_match, - ACTIONS(268), 1, - anon_sym_if, - ACTIONS(270), 1, - anon_sym_handle, - ACTIONS(272), 1, - anon_sym_kernel, - ACTIONS(274), 1, - anon_sym_select, - ACTIONS(278), 1, - anon_sym_await, - ACTIONS(280), 1, - anon_sym_spawn, - ACTIONS(282), 1, - anon_sym_yield, - ACTIONS(284), 1, - anon_sym_send, - ACTIONS(286), 1, - anon_sym_recv, - ACTIONS(288), 1, - anon_sym_perform, - ACTIONS(290), 1, - anon_sym_resume, - ACTIONS(294), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(255), 1, - sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16349,11 +16278,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16365,7 +16294,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16379,7 +16308,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9725] = 28, + [9533] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -16420,10 +16349,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(232), 1, + STATE(239), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16435,11 +16364,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16451,7 +16380,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16465,7 +16394,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9839] = 28, + [9647] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -16506,10 +16435,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(257), 1, + STATE(240), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16521,11 +16450,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16537,7 +16466,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16551,153 +16480,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9953] = 28, - ACTIONS(11), 1, - anon_sym_LBRACE, - ACTIONS(19), 1, - anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_match, - ACTIONS(37), 1, - anon_sym_if, - ACTIONS(39), 1, - anon_sym_handle, - ACTIONS(41), 1, - anon_sym_kernel, - ACTIONS(43), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_await, - ACTIONS(47), 1, - anon_sym_spawn, - ACTIONS(49), 1, - anon_sym_yield, - ACTIONS(51), 1, - anon_sym_send, - ACTIONS(53), 1, - anon_sym_recv, - ACTIONS(55), 1, - anon_sym_perform, - ACTIONS(57), 1, - anon_sym_resume, - ACTIONS(67), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(443), 1, - sym_expression, - ACTIONS(65), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(31), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(69), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(489), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(456), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(458), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [10067] = 28, - ACTIONS(194), 1, + [9761] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(339), 1, + STATE(243), 1, sym_expression, - ACTIONS(238), 2, + STATE(250), 1, + sym_qualified_path, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16709,7 +16552,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16723,7 +16566,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10181] = 28, + [9875] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -16764,10 +16607,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(261), 1, + STATE(244), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16779,11 +16622,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16795,7 +16638,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16809,67 +16652,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10295] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [9989] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(264), 1, + STATE(465), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16881,7 +16724,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16895,67 +16738,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10409] = 28, - ACTIONS(252), 1, + [10103] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(271), 1, + STATE(301), 1, sym_expression, - ACTIONS(292), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16967,7 +16810,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16981,7 +16824,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10523] = 28, + [10217] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17022,10 +16865,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(275), 1, + STATE(246), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17037,11 +16880,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17053,7 +16896,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17067,7 +16910,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10637] = 28, + [10331] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17108,10 +16951,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(277), 1, + STATE(248), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17123,11 +16966,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17139,7 +16982,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17153,7 +16996,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10751] = 28, + [10445] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17194,10 +17037,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(280), 1, + STATE(249), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17209,11 +17052,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17225,7 +17068,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17239,67 +17082,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10865] = 28, - ACTIONS(194), 1, + [10559] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(374), 1, + STATE(252), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17311,7 +17154,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17325,67 +17168,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10979] = 28, - ACTIONS(194), 1, + [10673] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(375), 1, + STATE(233), 1, sym_expression, - ACTIONS(238), 2, + STATE(250), 1, + sym_qualified_path, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17397,7 +17240,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17411,7 +17254,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11093] = 28, + [10787] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17452,10 +17295,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(281), 1, + STATE(234), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17467,11 +17310,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17483,7 +17326,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17497,67 +17340,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11207] = 28, - ACTIONS(194), 1, + [10901] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(377), 1, + STATE(345), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17569,7 +17412,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17583,67 +17426,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11321] = 28, - ACTIONS(252), 1, + [11015] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(282), 1, + STATE(353), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17655,7 +17498,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17669,7 +17512,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11435] = 28, + [11129] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17710,10 +17553,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(283), 1, + STATE(237), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17725,11 +17568,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17741,7 +17584,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17755,67 +17598,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11549] = 28, - ACTIONS(252), 1, + [11243] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(286), 1, + STATE(355), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17827,7 +17670,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17841,67 +17684,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11663] = 28, - ACTIONS(194), 1, + [11357] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(382), 1, + STATE(241), 1, sym_expression, - ACTIONS(238), 2, + STATE(250), 1, + sym_qualified_path, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17913,7 +17756,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17927,67 +17770,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11777] = 28, - ACTIONS(194), 1, + [11471] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(383), 1, + STATE(242), 1, sym_expression, - ACTIONS(238), 2, + STATE(250), 1, + sym_qualified_path, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17999,7 +17842,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18013,7 +17856,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11891] = 28, + [11585] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -18054,10 +17897,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(288), 1, + STATE(247), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -18069,11 +17912,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18085,7 +17928,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18099,67 +17942,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12005] = 28, - ACTIONS(194), 1, + [11699] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(356), 1, + STATE(307), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18171,7 +18014,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18185,67 +18028,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12119] = 28, - ACTIONS(194), 1, + [11813] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(359), 1, + STATE(330), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18257,7 +18100,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18271,7 +18114,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12233] = 28, + [11927] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -18312,9 +18155,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(241), 1, + STATE(253), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -18327,11 +18170,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18343,7 +18186,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18357,67 +18200,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12347] = 28, - ACTIONS(194), 1, + [12041] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(369), 1, + STATE(612), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18429,7 +18272,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18443,67 +18286,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12461] = 28, - ACTIONS(194), 1, + [12155] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(364), 1, + STATE(325), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18515,7 +18358,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18529,67 +18372,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12575] = 28, - ACTIONS(252), 1, + [12269] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(234), 1, + STATE(298), 1, sym_expression, - ACTIONS(292), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18601,7 +18444,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18615,67 +18458,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12689] = 28, - ACTIONS(194), 1, - sym_identifier, - ACTIONS(198), 1, + [12383] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(202), 1, - anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, - anon_sym_PIPE, - ACTIONS(376), 1, - anon_sym_LBRACK, - STATE(293), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(299), 1, + STATE(466), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18687,7 +18530,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18701,67 +18544,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12803] = 28, - ACTIONS(194), 1, + [12497] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(301), 1, + STATE(251), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18773,7 +18616,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18787,67 +18630,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12917] = 28, - ACTIONS(194), 1, + [12611] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(361), 1, + STATE(299), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18859,7 +18702,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18873,153 +18716,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13031] = 28, - ACTIONS(194), 1, + [12725] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(376), 1, + STATE(300), 1, sym_expression, - ACTIONS(238), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(222), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(242), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(379), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(380), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(381), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13145] = 28, - ACTIONS(194), 1, - sym_identifier, - ACTIONS(198), 1, - anon_sym_LBRACE, - ACTIONS(202), 1, - anon_sym_fn, - ACTIONS(204), 1, - anon_sym_LPAREN, - ACTIONS(212), 1, - anon_sym_match, - ACTIONS(214), 1, - anon_sym_if, - ACTIONS(216), 1, - anon_sym_handle, - ACTIONS(218), 1, - anon_sym_kernel, - ACTIONS(220), 1, - anon_sym_select, - ACTIONS(224), 1, - anon_sym_await, - ACTIONS(226), 1, - anon_sym_spawn, - ACTIONS(228), 1, - anon_sym_yield, - ACTIONS(230), 1, - anon_sym_send, - ACTIONS(232), 1, - anon_sym_recv, - ACTIONS(234), 1, - anon_sym_perform, - ACTIONS(236), 1, - anon_sym_resume, - ACTIONS(240), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(374), 1, - anon_sym_PIPE, - ACTIONS(376), 1, - anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(384), 1, - sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19031,7 +18788,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19045,67 +18802,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13259] = 28, - ACTIONS(194), 1, + [12839] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(300), 1, + STATE(256), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19117,7 +18874,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19131,67 +18888,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13373] = 28, - ACTIONS(194), 1, + [12953] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(306), 1, + STATE(302), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19203,7 +18960,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19217,67 +18974,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13487] = 28, - ACTIONS(194), 1, + [13067] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(319), 1, + STATE(303), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19289,7 +19046,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19303,7 +19060,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13601] = 28, + [13181] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -19344,9 +19101,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(558), 1, + STATE(561), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -19359,11 +19116,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19375,7 +19132,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19389,153 +19146,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13715] = 28, - ACTIONS(194), 1, + [13295] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(333), 1, + STATE(305), 1, sym_expression, - ACTIONS(238), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(222), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(242), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(379), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(380), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(381), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13829] = 28, - ACTIONS(194), 1, - sym_identifier, - ACTIONS(198), 1, - anon_sym_LBRACE, - ACTIONS(202), 1, - anon_sym_fn, - ACTIONS(204), 1, - anon_sym_LPAREN, - ACTIONS(212), 1, - anon_sym_match, - ACTIONS(214), 1, - anon_sym_if, - ACTIONS(216), 1, - anon_sym_handle, - ACTIONS(218), 1, - anon_sym_kernel, - ACTIONS(220), 1, - anon_sym_select, - ACTIONS(224), 1, - anon_sym_await, - ACTIONS(226), 1, - anon_sym_spawn, - ACTIONS(228), 1, - anon_sym_yield, - ACTIONS(230), 1, - anon_sym_send, - ACTIONS(232), 1, - anon_sym_recv, - ACTIONS(234), 1, - anon_sym_perform, - ACTIONS(236), 1, - anon_sym_resume, - ACTIONS(240), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(374), 1, - anon_sym_PIPE, - ACTIONS(376), 1, - anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(334), 1, - sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19547,7 +19218,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19561,67 +19232,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13943] = 28, - ACTIONS(194), 1, + [13409] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(349), 1, + STATE(306), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19633,7 +19304,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19647,67 +19318,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14057] = 28, - ACTIONS(194), 1, + [13523] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(357), 1, + STATE(308), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19719,7 +19390,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19733,67 +19404,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14171] = 28, - ACTIONS(194), 1, + [13637] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(358), 1, + STATE(309), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19805,7 +19476,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19819,67 +19490,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14285] = 28, - ACTIONS(194), 1, + [13751] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(360), 1, + STATE(310), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19891,7 +19562,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19905,67 +19576,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14399] = 28, - ACTIONS(194), 1, + [13865] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(362), 1, + STATE(311), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19977,7 +19648,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19991,67 +19662,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14513] = 28, - ACTIONS(194), 1, + [13979] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(363), 1, + STATE(312), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20063,7 +19734,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20077,67 +19748,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14627] = 28, - ACTIONS(194), 1, + [14093] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(365), 1, + STATE(313), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20149,7 +19820,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20163,67 +19834,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14741] = 28, - ACTIONS(194), 1, + [14207] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(366), 1, + STATE(314), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20235,7 +19906,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20249,67 +19920,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14855] = 28, - ACTIONS(194), 1, + [14321] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(367), 1, + STATE(315), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20321,7 +19992,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20335,67 +20006,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14969] = 28, - ACTIONS(194), 1, + [14435] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(368), 1, + STATE(316), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20407,7 +20078,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20421,67 +20092,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15083] = 28, - ACTIONS(194), 1, + [14549] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(370), 1, + STATE(317), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20493,7 +20164,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20507,67 +20178,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15197] = 28, - ACTIONS(194), 1, + [14663] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(371), 1, + STATE(318), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20579,7 +20250,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20593,67 +20264,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15311] = 28, - ACTIONS(194), 1, + [14777] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(372), 1, + STATE(319), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20665,7 +20336,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20679,67 +20350,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15425] = 28, - ACTIONS(194), 1, + [14891] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(373), 1, + STATE(320), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20751,7 +20422,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20765,67 +20436,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15539] = 28, - ACTIONS(194), 1, + [15005] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(378), 1, + STATE(321), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20837,7 +20508,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20851,67 +20522,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15653] = 28, - ACTIONS(11), 1, + [15119] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(471), 1, + ACTIONS(380), 1, + anon_sym_PIPE, + ACTIONS(382), 1, + anon_sym_LBRACK, + STATE(322), 1, sym_expression, - ACTIONS(65), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20923,7 +20594,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20937,67 +20608,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15767] = 28, - ACTIONS(194), 1, + [15233] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(309), 1, + STATE(323), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21009,7 +20680,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21023,67 +20694,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15881] = 28, - ACTIONS(194), 1, + [15347] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(310), 1, + STATE(324), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21095,7 +20766,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21109,67 +20780,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15995] = 28, - ACTIONS(194), 1, + [15461] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(311), 1, + STATE(356), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21181,7 +20852,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21195,67 +20866,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16109] = 28, - ACTIONS(194), 1, + [15575] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(312), 1, + STATE(326), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21267,7 +20938,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21281,67 +20952,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16223] = 28, - ACTIONS(194), 1, + [15689] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(313), 1, + STATE(327), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21353,7 +21024,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21367,67 +21038,153 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16337] = 28, - ACTIONS(194), 1, + [15803] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(328), 1, + sym_expression, + STATE(329), 1, sym_qualified_path, - STATE(314), 1, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(109), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(381), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(386), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(391), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [15917] = 28, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, + anon_sym_match, + ACTIONS(37), 1, + anon_sym_if, + ACTIONS(39), 1, + anon_sym_handle, + ACTIONS(41), 1, + anon_sym_kernel, + ACTIONS(43), 1, + anon_sym_select, + ACTIONS(45), 1, + anon_sym_await, + ACTIONS(47), 1, + anon_sym_spawn, + ACTIONS(49), 1, + anon_sym_yield, + ACTIONS(51), 1, + anon_sym_send, + ACTIONS(53), 1, + anon_sym_recv, + ACTIONS(55), 1, + anon_sym_perform, + ACTIONS(57), 1, + anon_sym_resume, + ACTIONS(67), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(453), 1, sym_expression, - ACTIONS(238), 2, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21439,7 +21196,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21453,67 +21210,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16451] = 28, - ACTIONS(194), 1, + [16031] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(316), 1, + STATE(334), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21525,7 +21282,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21539,67 +21296,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16565] = 28, - ACTIONS(194), 1, + [16145] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(320), 1, + STATE(335), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21611,7 +21368,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21625,67 +21382,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16679] = 28, - ACTIONS(194), 1, + [16259] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(327), 1, + STATE(336), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21697,7 +21454,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21711,67 +21468,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16793] = 28, - ACTIONS(194), 1, + [16373] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(331), 1, + STATE(337), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21783,7 +21540,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21797,67 +21554,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16907] = 28, - ACTIONS(194), 1, + [16487] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(335), 1, + STATE(338), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21869,7 +21626,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21883,67 +21640,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17021] = 28, - ACTIONS(194), 1, + [16601] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(338), 1, + STATE(339), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21955,7 +21712,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21969,67 +21726,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17135] = 28, - ACTIONS(194), 1, + [16715] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, STATE(340), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22041,7 +21798,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22055,67 +21812,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17249] = 28, - ACTIONS(194), 1, + [16829] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, STATE(341), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22127,7 +21884,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22141,67 +21898,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17363] = 28, - ACTIONS(194), 1, + [16943] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(294), 1, + STATE(342), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22213,7 +21970,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22227,67 +21984,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17477] = 28, - ACTIONS(194), 1, + [17057] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(344), 1, + STATE(343), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22299,7 +22056,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22313,67 +22070,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17591] = 28, - ACTIONS(194), 1, + [17171] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(346), 1, + STATE(344), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22385,7 +22142,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22399,67 +22156,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17705] = 28, - ACTIONS(194), 1, + [17285] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, - sym_qualified_path, - STATE(350), 1, + STATE(297), 1, sym_expression, - ACTIONS(238), 2, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22471,7 +22228,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22485,67 +22242,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17819] = 28, - ACTIONS(194), 1, + [17399] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(329), 1, sym_qualified_path, - STATE(352), 1, + STATE(346), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22557,7 +22314,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22571,67 +22328,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17933] = 28, - ACTIONS(11), 1, + [17513] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(380), 1, + anon_sym_PIPE, + ACTIONS(382), 1, + anon_sym_LBRACK, + STATE(329), 1, sym_qualified_path, - STATE(444), 1, + STATE(347), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22643,7 +22400,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22657,67 +22414,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18047] = 28, - ACTIONS(252), 1, + [17627] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(235), 1, + STATE(348), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22729,7 +22486,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22743,67 +22500,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18161] = 28, - ACTIONS(11), 1, + [17741] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(380), 1, + anon_sym_PIPE, + ACTIONS(382), 1, + anon_sym_LBRACK, + STATE(329), 1, sym_qualified_path, - STATE(445), 1, + STATE(349), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22815,7 +22572,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22829,67 +22586,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18275] = 28, - ACTIONS(252), 1, + [17855] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(266), 1, + ACTIONS(91), 1, + anon_sym_LPAREN, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - ACTIONS(378), 1, - anon_sym_LPAREN, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(235), 1, + STATE(350), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22901,7 +22658,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22915,67 +22672,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18389] = 28, - ACTIONS(252), 1, + [17969] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(237), 1, + STATE(351), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22987,7 +22744,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23001,67 +22758,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18503] = 28, - ACTIONS(11), 1, + [18083] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(380), 1, + anon_sym_PIPE, + ACTIONS(382), 1, + anon_sym_LBRACK, + STATE(329), 1, sym_qualified_path, - STATE(446), 1, + STATE(352), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23073,7 +22830,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23087,7 +22844,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18617] = 28, + [18197] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -23128,9 +22885,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(447), 1, + STATE(468), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -23143,11 +22900,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23159,7 +22916,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23173,7 +22930,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18731] = 28, + [18311] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -23214,9 +22971,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(545), 1, + STATE(254), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23229,11 +22986,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23245,7 +23002,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23259,67 +23016,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18845] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [18425] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(624), 1, + STATE(469), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23331,7 +23088,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23345,15 +23102,13 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18959] = 28, + [18539] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, ACTIONS(266), 1, anon_sym_match, ACTIONS(268), 1, @@ -23386,9 +23141,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(384), 1, + anon_sym_LPAREN, + STATE(250), 1, sym_qualified_path, - STATE(516), 1, + STATE(254), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23401,11 +23158,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23417,7 +23174,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23431,7 +23188,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19073] = 28, + [18653] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -23472,10 +23229,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(517), 1, + STATE(238), 1, sym_expression, + STATE(250), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -23487,11 +23244,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23503,7 +23260,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23517,67 +23274,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19187] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [18767] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(620), 1, + STATE(470), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23589,7 +23346,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23603,67 +23360,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19301] = 28, - ACTIONS(194), 1, - sym_identifier, - ACTIONS(198), 1, + [18881] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(202), 1, - anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, - anon_sym_PIPE, - ACTIONS(376), 1, - anon_sym_LBRACK, - STATE(293), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(460), 1, sym_qualified_path, - STATE(295), 1, + STATE(471), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23675,7 +23432,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23689,67 +23446,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19415] = 28, - ACTIONS(194), 1, + [18995] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(212), 1, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(380), 1, - anon_sym_LPAREN, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(295), 1, + STATE(599), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23761,7 +23518,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23775,67 +23532,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19529] = 28, - ACTIONS(194), 1, + [19109] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(297), 1, + STATE(620), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23847,7 +23604,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23861,67 +23618,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19643] = 28, - ACTIONS(11), 1, + [19223] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, sym_qualified_path, - STATE(573), 1, + STATE(472), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23933,7 +23690,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23947,67 +23704,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19757] = 28, - ACTIONS(11), 1, + [19337] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(19), 1, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, sym_qualified_path, - STATE(450), 1, + STATE(496), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24019,7 +23776,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24033,7 +23790,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19871] = 28, + [19451] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -24074,9 +23831,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(451), 1, + STATE(624), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24089,11 +23846,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24105,7 +23862,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24119,67 +23876,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19985] = 28, - ACTIONS(11), 1, + [19565] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, + anon_sym_LPAREN, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(37), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(39), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(41), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(43), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(53), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(55), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(57), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(67), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, + ACTIONS(380), 1, + anon_sym_PIPE, ACTIONS(382), 1, - anon_sym_LPAREN, - STATE(433), 1, + anon_sym_LBRACK, + STATE(329), 1, sym_qualified_path, - STATE(471), 1, + STATE(331), 1, sym_expression, - ACTIONS(65), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(31), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(69), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24191,7 +23948,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24205,7 +23962,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20099] = 28, + [19679] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -24246,9 +24003,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(459), 1, + STATE(593), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -24261,11 +24018,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24277,7 +24034,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24291,67 +24048,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20213] = 28, - ACTIONS(252), 1, + [19793] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + ACTIONS(386), 1, + anon_sym_LPAREN, + STATE(329), 1, sym_qualified_path, - STATE(614), 1, + STATE(331), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24363,7 +24120,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24377,67 +24134,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20327] = 28, - ACTIONS(252), 1, + [19907] = 28, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(329), 1, sym_qualified_path, - STATE(579), 1, + STATE(332), 1, sym_expression, - ACTIONS(292), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(381), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(386), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24449,7 +24206,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(391), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24463,7 +24220,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20441] = 28, + [20021] = 28, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(19), 1, @@ -24504,9 +24261,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(433), 1, + STATE(460), 1, sym_qualified_path, - STATE(470), 1, + STATE(461), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -24519,11 +24276,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(489), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(456), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24535,7 +24292,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(458), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24549,7 +24306,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20555] = 28, + [20135] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -24590,9 +24347,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(584), 1, + STATE(448), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24605,11 +24362,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24621,7 +24378,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24635,67 +24392,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20669] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [20249] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(575), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + ACTIONS(388), 1, + anon_sym_LPAREN, + STATE(453), 1, sym_expression, - ACTIONS(292), 2, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24707,7 +24464,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24721,67 +24478,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20783] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [20363] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(576), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(456), 1, sym_expression, - ACTIONS(292), 2, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24793,7 +24550,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24807,67 +24564,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20897] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [20477] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(577), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(454), 1, sym_expression, - ACTIONS(292), 2, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24879,7 +24636,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24893,7 +24650,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21011] = 28, + [20591] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -24934,9 +24691,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(581), 1, + STATE(583), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24949,11 +24706,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24965,7 +24722,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24979,7 +24736,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21125] = 28, + [20705] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25020,9 +24777,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(585), 1, + STATE(558), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25035,11 +24792,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25051,7 +24808,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25065,67 +24822,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21239] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, + [20819] = 28, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(37), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(39), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(41), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(43), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(45), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(47), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(49), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(51), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(53), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(55), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(57), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(67), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(230), 1, - sym_qualified_path, - STATE(587), 1, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(449), 1, sym_expression, - ACTIONS(292), 2, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(31), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(69), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(477), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(473), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25137,7 +24894,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(493), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25151,7 +24908,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21353] = 28, + [20933] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25192,9 +24949,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(589), 1, + STATE(539), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25207,11 +24964,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25223,7 +24980,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25237,7 +24994,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21467] = 28, + [21047] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25278,9 +25035,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(592), 1, + STATE(544), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25293,11 +25050,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25309,7 +25066,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25323,7 +25080,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21581] = 28, + [21161] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25364,9 +25121,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(594), 1, + STATE(545), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25379,11 +25136,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25395,7 +25152,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25409,7 +25166,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21695] = 28, + [21275] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25450,9 +25207,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(595), 1, + STATE(549), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25465,11 +25222,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25481,7 +25238,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25495,7 +25252,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21809] = 28, + [21389] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25536,9 +25293,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(598), 1, + STATE(553), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25551,11 +25308,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25567,7 +25324,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25581,7 +25338,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21923] = 28, + [21503] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25622,9 +25379,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(600), 1, + STATE(506), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25637,11 +25394,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25653,7 +25410,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25667,7 +25424,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22037] = 28, + [21617] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25708,9 +25465,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(602), 1, + STATE(563), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25723,11 +25480,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25739,7 +25496,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25753,93 +25510,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22151] = 28, - ACTIONS(11), 1, - anon_sym_LBRACE, - ACTIONS(19), 1, - anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_match, - ACTIONS(37), 1, - anon_sym_if, - ACTIONS(39), 1, - anon_sym_handle, - ACTIONS(41), 1, - anon_sym_kernel, - ACTIONS(43), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_await, - ACTIONS(47), 1, - anon_sym_spawn, - ACTIONS(49), 1, - anon_sym_yield, - ACTIONS(51), 1, - anon_sym_send, - ACTIONS(53), 1, - anon_sym_recv, - ACTIONS(55), 1, - anon_sym_perform, - ACTIONS(57), 1, - anon_sym_resume, - ACTIONS(67), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(476), 1, - sym_expression, - ACTIONS(65), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(31), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(69), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(489), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(456), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(458), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [22265] = 28, + [21731] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25880,9 +25551,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(622), 1, + STATE(568), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25895,11 +25566,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25911,7 +25582,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25925,7 +25596,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22379] = 28, + [21845] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -25966,9 +25637,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(623), 1, + STATE(573), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25981,11 +25652,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25997,7 +25668,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26011,7 +25682,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22493] = 28, + [21959] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -26052,9 +25723,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(609), 1, + STATE(574), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26067,11 +25738,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26083,7 +25754,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26097,7 +25768,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22607] = 28, + [22073] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -26138,9 +25809,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(520), 1, + STATE(578), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26153,11 +25824,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26169,7 +25840,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26183,7 +25854,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22721] = 28, + [22187] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -26224,9 +25895,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(612), 1, + STATE(581), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26239,11 +25910,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26255,7 +25926,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26269,93 +25940,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22835] = 28, - ACTIONS(11), 1, - anon_sym_LBRACE, - ACTIONS(19), 1, - anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_match, - ACTIONS(37), 1, - anon_sym_if, - ACTIONS(39), 1, - anon_sym_handle, - ACTIONS(41), 1, - anon_sym_kernel, - ACTIONS(43), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_await, - ACTIONS(47), 1, - anon_sym_spawn, - ACTIONS(49), 1, - anon_sym_yield, - ACTIONS(51), 1, - anon_sym_send, - ACTIONS(53), 1, - anon_sym_recv, - ACTIONS(55), 1, - anon_sym_perform, - ACTIONS(57), 1, - anon_sym_resume, - ACTIONS(67), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(433), 1, - sym_qualified_path, - STATE(513), 1, - sym_expression, - ACTIONS(65), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(31), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(69), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(489), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(456), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(458), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [22949] = 28, + [22301] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -26396,9 +25981,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(230), 1, + STATE(250), 1, sym_qualified_path, - STATE(626), 1, + STATE(584), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26411,11 +25996,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(250), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(240), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26427,7 +26012,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(249), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26441,67 +26026,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23063] = 28, - ACTIONS(194), 1, + [22415] = 28, + ACTIONS(252), 1, sym_identifier, - ACTIONS(198), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(202), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(204), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(212), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(214), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(216), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(218), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(220), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(224), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(226), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(228), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(230), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(232), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(234), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(236), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(240), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(374), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(376), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(293), 1, + STATE(250), 1, sym_qualified_path, - STATE(328), 1, + STATE(585), 1, sym_expression, - ACTIONS(238), 2, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(222), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(242), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(379), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(380), 11, + STATE(258), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26513,7 +26098,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(381), 13, + STATE(259), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26527,14 +26112,788 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23177] = 5, + [22529] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(615), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [22643] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(618), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [22757] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(602), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [22871] = 28, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, + anon_sym_match, + ACTIONS(37), 1, + anon_sym_if, + ACTIONS(39), 1, + anon_sym_handle, + ACTIONS(41), 1, + anon_sym_kernel, + ACTIONS(43), 1, + anon_sym_select, + ACTIONS(45), 1, + anon_sym_await, + ACTIONS(47), 1, + anon_sym_spawn, + ACTIONS(49), 1, + anon_sym_yield, + ACTIONS(51), 1, + anon_sym_send, + ACTIONS(53), 1, + anon_sym_recv, + ACTIONS(55), 1, + anon_sym_perform, + ACTIONS(57), 1, + anon_sym_resume, + ACTIONS(67), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(459), 1, + sym_expression, + STATE(460), 1, + sym_qualified_path, + ACTIONS(65), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(31), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(69), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(477), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(473), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(493), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [22985] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(512), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [23099] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(605), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [23213] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(395), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [23327] = 28, + ACTIONS(252), 1, + sym_identifier, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + STATE(250), 1, + sym_qualified_path, + STATE(626), 1, + sym_expression, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(258), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(259), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [23441] = 28, + ACTIONS(81), 1, + sym_identifier, + ACTIONS(85), 1, + anon_sym_LBRACE, + ACTIONS(89), 1, + anon_sym_fn, + ACTIONS(91), 1, + anon_sym_LPAREN, + ACTIONS(99), 1, + anon_sym_match, + ACTIONS(101), 1, + anon_sym_if, + ACTIONS(103), 1, + anon_sym_handle, + ACTIONS(105), 1, + anon_sym_kernel, + ACTIONS(107), 1, + anon_sym_select, + ACTIONS(111), 1, + anon_sym_await, + ACTIONS(113), 1, + anon_sym_spawn, + ACTIONS(115), 1, + anon_sym_yield, + ACTIONS(117), 1, + anon_sym_send, + ACTIONS(119), 1, + anon_sym_recv, + ACTIONS(121), 1, + anon_sym_perform, + ACTIONS(123), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(380), 1, + anon_sym_PIPE, + ACTIONS(382), 1, + anon_sym_LBRACK, + STATE(304), 1, + sym_expression, + STATE(329), 1, + sym_qualified_path, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(109), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(381), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(386), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(391), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [23555] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(388), 1, + ACTIONS(394), 1, sym__doc_comment_line, - STATE(223), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - ACTIONS(386), 8, + ACTIONS(392), 8, anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, @@ -26543,7 +26902,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, sym_float, - ACTIONS(384), 34, + ACTIONS(390), 34, anon_sym_namespace, anon_sym_let, anon_sym_mut, @@ -26578,14 +26937,14 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23233] = 5, + [23611] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(395), 1, + ACTIONS(400), 1, sym__doc_comment_line, - STATE(223), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - ACTIONS(393), 8, + ACTIONS(398), 8, anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, @@ -26594,7 +26953,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, sym_float, - ACTIONS(391), 34, + ACTIONS(396), 34, anon_sym_namespace, anon_sym_let, anon_sym_mut, @@ -26629,10 +26988,10 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23289] = 3, + [23667] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(397), 10, + ACTIONS(403), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -26643,7 +27002,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(399), 30, + ACTIONS(405), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -26674,10 +27033,10 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23337] = 3, + [23715] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(397), 10, + ACTIONS(403), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -26688,7 +27047,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(399), 30, + ACTIONS(405), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -26719,21 +27078,22 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23385] = 8, + [23763] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(405), 1, + ACTIONS(411), 1, anon_sym_COLON_COLON, - ACTIONS(407), 1, + ACTIONS(413), 1, anon_sym_LBRACE, - ACTIONS(410), 1, - anon_sym_LT, - STATE(228), 1, + ACTIONS(416), 1, + anon_sym_LT2, + STATE(231), 1, aux_sym_qualified_path_repeat1, - STATE(1654), 1, + STATE(1680), 1, sym_type_arguments, - ACTIONS(401), 12, + ACTIONS(407), 13, anon_sym_COLON, + anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, @@ -26745,7 +27105,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(403), 21, + ACTIONS(409), 21, sym__call_open_gap, anon_sym_DOT, anon_sym_RBRACE, @@ -26767,14 +27127,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23441] = 5, + [23820] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(405), 1, + ACTIONS(411), 1, anon_sym_COLON_COLON, - STATE(229), 1, + STATE(232), 1, aux_sym_qualified_path_repeat1, - ACTIONS(413), 13, + ACTIONS(419), 14, anon_sym_COLON, anon_sym_LT, anon_sym_GT, @@ -26782,13 +27142,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(415), 22, + ACTIONS(421), 22, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -26811,14 +27172,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23490] = 5, + [23870] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(421), 1, + ACTIONS(427), 1, anon_sym_COLON_COLON, - STATE(229), 1, + STATE(232), 1, aux_sym_qualified_path_repeat1, - ACTIONS(417), 13, + ACTIONS(423), 14, anon_sym_COLON, anon_sym_LT, anon_sym_GT, @@ -26826,13 +27187,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(419), 22, + ACTIONS(425), 22, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -26855,30 +27217,200 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23539] = 6, + [23920] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(424), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - STATE(1654), 1, - sym_type_arguments, - ACTIONS(401), 11, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(436), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(430), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [23995] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(464), 8, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(462), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(403), 22, + [24068] = 12, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(466), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(468), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_float, + [24131] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(466), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(468), 19, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_COMMA, @@ -26896,67 +27428,363 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_PERCENT, + sym_float, + [24188] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(472), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(475), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, sym_float, - [23589] = 3, + ACTIONS(470), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24263] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(417), 13, - anon_sym_COLON, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(479), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(477), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, - anon_sym_SLASH, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(419), 23, - sym__call_open_gap, + [24338] = 15, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, anon_sym_DOT, - anon_sym_COLON_COLON, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(466), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(468), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + sym_float, + [24407] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + ACTIONS(466), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(468), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_float, + [24474] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PERCENT, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(483), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(481), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24549] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(487), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, sym_float, - [23633] = 9, + ACTIONS(485), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24624] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(427), 11, + ACTIONS(466), 11, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -26968,7 +27796,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(431), 17, + ACTIONS(468), 17, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -26986,10 +27814,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, sym_float, - [23688] = 3, + [24685] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(443), 12, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(489), 12, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -27002,9 +27840,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(445), 23, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(491), 20, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -27024,44 +27860,218 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, + sym_float, + [24740] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(495), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(493), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24815] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(499), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(502), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, sym_float, - [23731] = 16, + ACTIONS(497), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24890] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(506), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(509), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(504), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [24965] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(451), 7, + ACTIONS(513), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27069,7 +28079,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(447), 9, + ACTIONS(511), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, @@ -27079,53 +28089,72 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23800] = 6, + [25040] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(439), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(465), 12, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(517), 8, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(515), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, - anon_sym_SLASH, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(467), 20, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - sym_float, - [23849] = 3, + [25113] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(469), 12, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(519), 1, + anon_sym_LBRACE, + STATE(1680), 1, + sym_type_arguments, + ACTIONS(407), 12, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -27138,10 +28167,9 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(471), 23, + ACTIONS(409), 22, sym__call_open_gap, anon_sym_DOT, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_COMMA, @@ -27162,42 +28190,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23892] = 16, + [25164] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(524), 1, anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(475), 7, + ACTIONS(527), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27205,7 +28237,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(473), 9, + ACTIONS(522), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, @@ -27215,42 +28247,103 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23961] = 16, + [25239] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(531), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(534), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(529), 9, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [25314] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(479), 7, + ACTIONS(538), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27258,7 +28351,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(477), 9, + ACTIONS(536), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, @@ -27268,10 +28361,20 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [24030] = 3, + [25389] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(481), 12, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(540), 12, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -27284,9 +28387,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(483), 23, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(542), 20, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -27306,32 +28407,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [24073] = 3, + [25444] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(485), 12, + ACTIONS(423), 14, + anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(487), 23, + ACTIONS(425), 23, sym__call_open_gap, anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_COMMA, - anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_RBRACK, @@ -27348,42 +28450,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24116] = 16, + [25489] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(491), 1, - anon_sym_LBRACE, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(494), 7, + ACTIONS(546), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27391,7 +28497,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(489), 9, + ACTIONS(544), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, @@ -27401,23 +28507,24 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [24185] = 3, + [25564] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(496), 12, + ACTIONS(548), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(498), 23, + ACTIONS(550), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27441,23 +28548,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24228] = 3, + [25608] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(500), 12, + ACTIONS(552), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(502), 23, + ACTIONS(554), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27481,23 +28589,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24271] = 3, + [25652] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(504), 12, + ACTIONS(407), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(506), 23, + ACTIONS(409), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27521,23 +28630,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24314] = 3, + [25696] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(508), 12, + ACTIONS(556), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(510), 23, + ACTIONS(559), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27561,23 +28671,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24357] = 3, + [25740] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(512), 12, + ACTIONS(562), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(514), 23, + ACTIONS(564), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27601,68 +28712,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24400] = 8, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(516), 1, - anon_sym_COLON_COLON, - ACTIONS(518), 1, - anon_sym_LBRACE, - STATE(291), 1, - aux_sym_qualified_path_repeat1, - STATE(1681), 1, - sym_type_arguments, - ACTIONS(401), 2, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(403), 28, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [24453] = 3, + [25784] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(521), 12, + ACTIONS(566), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(523), 23, + ACTIONS(568), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27686,23 +28753,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24496] = 3, + [25828] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(401), 12, + ACTIONS(570), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(403), 23, + ACTIONS(572), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27726,23 +28794,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24539] = 3, + [25872] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(525), 12, + ACTIONS(574), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(527), 23, + ACTIONS(576), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27766,23 +28835,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24582] = 3, + [25916] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(529), 12, + ACTIONS(578), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(531), 23, + ACTIONS(580), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27806,213 +28876,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24625] = 7, + [25960] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(427), 12, + ACTIONS(582), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(431), 19, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - sym_float, - [24676] = 10, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(427), 11, - anon_sym_LT, - anon_sym_GT, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(431), 15, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - sym_float, - [24733] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(427), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(431), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - sym_float, - [24796] = 12, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(427), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(431), 11, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - sym_float, - [24857] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(533), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(535), 23, + ACTIONS(584), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28036,29 +28917,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24900] = 6, + [26004] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(537), 12, + ACTIONS(586), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(539), 20, + ACTIONS(588), 23, + sym__call_open_gap, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -28078,24 +28956,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - [24949] = 3, + [26048] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(541), 12, + ACTIONS(590), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(543), 23, + ACTIONS(592), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28119,23 +28999,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [24992] = 3, + [26092] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(545), 12, + ACTIONS(594), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(547), 23, + ACTIONS(596), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28159,23 +29040,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25035] = 3, + [26136] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(549), 12, + ACTIONS(598), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(551), 23, + ACTIONS(600), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28199,76 +29081,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25078] = 16, + [26180] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(555), 1, - anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(558), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(553), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [25147] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(560), 12, + ACTIONS(602), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(562), 23, + ACTIONS(604), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28292,23 +29122,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25190] = 3, + [26224] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(564), 12, + ACTIONS(606), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(566), 23, + ACTIONS(608), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28332,76 +29163,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25233] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, - anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(570), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(568), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [25302] = 3, + [26268] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(572), 12, + ACTIONS(610), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(574), 23, + ACTIONS(612), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28425,23 +29204,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25345] = 3, + [26312] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(576), 12, + ACTIONS(614), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(579), 23, + ACTIONS(617), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28465,23 +29245,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25388] = 3, + [26356] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 12, + ACTIONS(620), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(584), 23, + ACTIONS(622), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28505,23 +29286,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25431] = 3, + [26400] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(586), 12, + ACTIONS(624), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(588), 23, + ACTIONS(626), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28545,23 +29327,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25474] = 3, + [26444] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(590), 12, + ACTIONS(628), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(593), 23, + ACTIONS(631), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28585,23 +29368,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25517] = 3, + [26488] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(596), 12, + ACTIONS(634), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(598), 23, + ACTIONS(636), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28625,75 +29409,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25560] = 15, + [26532] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(602), 8, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(600), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [25627] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(604), 12, + ACTIONS(638), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(607), 23, + ACTIONS(640), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28717,23 +29450,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25670] = 3, + [26576] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(610), 12, + ACTIONS(642), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(612), 23, + ACTIONS(644), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28757,23 +29491,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25713] = 3, + [26620] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(614), 12, + ACTIONS(646), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(616), 23, + ACTIONS(648), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28797,76 +29532,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25756] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(620), 1, - anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(623), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(618), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [25825] = 3, + [26664] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(625), 12, + ACTIONS(650), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(627), 23, + ACTIONS(652), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28890,76 +29573,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25868] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, - anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(631), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(629), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [25937] = 3, + [26708] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(633), 12, + ACTIONS(654), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(635), 23, + ACTIONS(656), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28983,23 +29614,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25980] = 3, + [26752] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(637), 12, + ACTIONS(658), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(639), 23, + ACTIONS(660), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29023,234 +29655,147 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26023] = 15, + [26796] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(662), 13, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(643), 8, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(641), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [26090] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(664), 23, sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(647), 1, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(650), 7, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(645), 9, + [26840] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(666), 13, + anon_sym_LT, + anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [26159] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(668), 23, sym__call_open_gap, - ACTIONS(449), 1, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(654), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(652), 9, + [26884] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(670), 13, + anon_sym_LT, + anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [26228] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(672), 23, sym__call_open_gap, - ACTIONS(449), 1, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(658), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(656), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [26297] = 3, + [26928] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(660), 12, + ACTIONS(674), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(662), 23, + ACTIONS(676), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29274,23 +29819,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26340] = 3, + [26972] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(664), 12, + ACTIONS(678), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(666), 23, + ACTIONS(680), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29314,76 +29860,65 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26383] = 16, + [27016] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(670), 1, - anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(682), 13, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(673), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(668), 9, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [26452] = 3, + ACTIONS(684), 23, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [27060] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(675), 12, + ACTIONS(686), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(677), 23, + ACTIONS(688), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29407,76 +29942,111 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26495] = 16, - ACTIONS(298), 1, + [27104] = 8, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(690), 1, + anon_sym_COLON_COLON, + ACTIONS(692), 1, + anon_sym_LBRACE, + STATE(295), 1, + aux_sym_qualified_path_repeat1, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(407), 3, + anon_sym_LT, + anon_sym_GT, anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(409), 28, sym__call_open_gap, - ACTIONS(449), 1, - anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(681), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(679), 9, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27158] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(695), 13, + anon_sym_LT, + anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [26564] = 3, + ACTIONS(697), 23, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [27202] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(683), 12, + ACTIONS(699), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, anon_sym_SLASH, + anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(685), 23, + ACTIONS(701), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29500,18 +30070,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26607] = 5, + [27246] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(687), 1, + ACTIONS(690), 1, anon_sym_COLON_COLON, - STATE(290), 1, + STATE(296), 1, aux_sym_qualified_path_repeat1, - ACTIONS(417), 3, + ACTIONS(419), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(419), 29, + anon_sym_LT2, + ACTIONS(421), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29541,23 +30112,300 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26653] = 5, + [27293] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(516), 1, + ACTIONS(703), 1, anon_sym_COLON_COLON, - STATE(290), 1, + STATE(296), 1, aux_sym_qualified_path_repeat1, - ACTIONS(413), 3, + ACTIONS(423), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(425), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27340] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(464), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27408] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(732), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27478] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(415), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(734), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27548] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(736), 13, anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27618] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(738), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -29565,37 +30413,264 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27688] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, anon_sym_QMARK, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, + ACTIONS(716), 1, anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + ACTIONS(740), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27758] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(742), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27828] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(744), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [27898] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, anon_sym_PIPE_GT, + ACTIONS(726), 1, anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(746), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26699] = 3, + [27968] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(417), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(419), 30, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, - anon_sym_COLON_COLON, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(748), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -29603,40 +30678,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26740] = 6, + [28038] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(690), 1, - anon_sym_LBRACE, - STATE(1681), 1, - sym_type_arguments, - ACTIONS(401), 2, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(403), 28, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(750), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -29644,59 +30731,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26787] = 15, + [28108] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(658), 13, + ACTIONS(752), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -29710,23 +30789,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26851] = 6, + [28178] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(715), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(465), 3, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(467), 26, - anon_sym_LBRACE, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(754), 13, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -29734,35 +30837,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26897] = 3, + [28248] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(469), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(471), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(756), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -29770,59 +30890,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [26937] = 15, + [28318] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(475), 13, + ACTIONS(758), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -29836,42 +30948,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27001] = 15, + [28388] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(479), 13, + ACTIONS(760), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -29885,42 +31001,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27065] = 15, + [28458] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(719), 13, + ACTIONS(762), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -29934,42 +31054,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27129] = 15, + [28528] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(721), 13, + ACTIONS(764), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -29983,42 +31107,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27193] = 15, + [28598] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(723), 13, + ACTIONS(766), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30032,19 +31160,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27257] = 3, + [28668] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(500), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(502), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(768), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30052,36 +31208,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27297] = 3, + [28738] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(504), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(506), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(770), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30089,36 +31261,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27337] = 3, + [28808] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(508), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(510), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(772), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30126,36 +31314,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27377] = 3, + [28878] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(512), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(514), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(774), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30163,59 +31367,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27417] = 15, + [28948] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(725), 13, + ACTIONS(776), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30229,19 +31425,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27481] = 3, + [29018] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(521), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(523), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(778), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30249,36 +31473,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27521] = 3, + [29088] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(529), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(531), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(780), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30286,42 +31526,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27561] = 7, + [29158] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(713), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(427), 3, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(431), 25, - anon_sym_LBRACE, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(782), 13, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30329,45 +31579,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27609] = 10, + [29228] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(711), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(427), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(709), 2, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(431), 21, - anon_sym_LBRACE, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(784), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30376,49 +31632,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27663] = 12, + [29298] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(705), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(431), 16, - anon_sym_LBRACE, + ACTIONS(786), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30427,42 +31685,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27721] = 11, + [29368] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(711), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(431), 17, - anon_sym_LBRACE, + ACTIONS(788), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30471,35 +31738,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27777] = 9, + [29438] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(711), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(427), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(431), 23, - anon_sym_LBRACE, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(790), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30508,37 +31791,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27829] = 6, + [29508] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(715), 1, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(537), 3, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(539), 26, - anon_sym_LBRACE, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(792), 13, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30546,33 +31844,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27875] = 3, + [29578] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(541), 3, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(794), 1, + anon_sym_LBRACE, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(407), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(543), 29, + ACTIONS(409), 28, sym__call_open_gap, anon_sym_DOT, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_let, @@ -30599,42 +31891,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27915] = 15, + [29626] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(727), 1, + ACTIONS(730), 1, anon_sym_LBRACE, - ACTIONS(697), 2, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(558), 13, + ACTIONS(797), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30648,53 +31944,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27979] = 3, + [29696] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(560), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(562), 29, - sym__call_open_gap, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, + ACTIONS(726), 1, anon_sym_LBRACK2, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [28019] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(564), 3, + ACTIONS(728), 1, + sym__call_open_gap, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(540), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(566), 29, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(542), 26, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -30716,48 +31983,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28059] = 15, + [29748] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(730), 13, + ACTIONS(479), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30771,42 +32041,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28123] = 15, + [29818] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(570), 13, + ACTIONS(495), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30820,16 +32094,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28187] = 3, + [29888] = 9, ACTIONS(3), 1, sym_line_comment, - ACTIONS(572), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(466), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(574), 29, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(468), 25, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -30850,26 +32134,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28227] = 3, + [29942] = 12, ACTIONS(3), 1, sym_line_comment, - ACTIONS(576), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(579), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(466), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(468), 21, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30884,29 +32182,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28267] = 3, + [30002] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(582), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(584), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(468), 16, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30916,34 +32232,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_effect, anon_sym_QMARK, anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28307] = 3, + [30066] = 13, ACTIONS(3), 1, sym_line_comment, - ACTIONS(586), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(588), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(468), 17, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30954,33 +32281,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28347] = 3, + [30128] = 11, ACTIONS(3), 1, sym_line_comment, - ACTIONS(590), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(593), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(466), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(468), 23, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30997,24 +32328,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28387] = 3, + [30186] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(596), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(489), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(598), 29, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(491), 26, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -31036,47 +32372,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28427] = 14, + [30238] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(799), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(602), 14, - anon_sym_LBRACE, + ACTIONS(502), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31090,42 +32430,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28489] = 15, + [30308] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(732), 13, + ACTIONS(513), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31139,56 +32483,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28553] = 3, + [30378] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(610), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(612), 29, - sym__call_open_gap, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + ACTIONS(712), 1, anon_sym_QMARK, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, + ACTIONS(716), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, anon_sym_PIPE_GT, + ACTIONS(726), 1, anon_sym_LBRACK2, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [28593] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(614), 3, + ACTIONS(728), 1, + sym__call_open_gap, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(616), 29, - sym__call_open_gap, - anon_sym_DOT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(517), 14, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31196,59 +32530,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28633] = 15, + [30446] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(734), 1, + ACTIONS(802), 1, anon_sym_LBRACE, - ACTIONS(697), 2, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(623), 13, + ACTIONS(534), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31262,19 +32588,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28697] = 3, + [30516] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(625), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(627), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(436), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31282,59 +32636,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28737] = 15, + [30586] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(737), 13, + ACTIONS(805), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31348,42 +32694,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28801] = 15, + [30656] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(807), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(739), 13, + ACTIONS(475), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31397,42 +32747,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28865] = 15, + [30726] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(631), 13, + ACTIONS(483), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31446,19 +32800,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28929] = 3, + [30796] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(633), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, + anon_sym_SLASH, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, + sym__call_open_gap, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(635), 29, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_LBRACE, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(487), 13, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31466,36 +32848,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28969] = 3, + [30866] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(637), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(639), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(810), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(509), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31503,58 +32901,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29009] = 14, + [30936] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(643), 14, - anon_sym_LBRACE, + ACTIONS(538), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31568,42 +32959,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29071] = 15, + [31006] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(813), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(741), 13, + ACTIONS(527), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31617,42 +33012,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29135] = 15, + [31076] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(743), 1, + ACTIONS(730), 1, anon_sym_LBRACE, - ACTIONS(697), 2, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(650), 13, + ACTIONS(546), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31666,42 +33065,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29199] = 15, + [31146] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(697), 2, + ACTIONS(730), 1, + anon_sym_LBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(654), 13, + ACTIONS(816), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31715,16 +33118,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29263] = 3, + [31216] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(660), 3, + ACTIONS(423), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(662), 29, + anon_sym_LT2, + ACTIONS(425), 30, sym__call_open_gap, anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -31752,19 +33157,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29303] = 3, + [31258] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(664), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(712), 1, + anon_sym_QMARK, + ACTIONS(714), 1, + anon_sym_PIPE_PIPE, + ACTIONS(716), 1, + anon_sym_AMP_AMP, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(666), 29, + ACTIONS(724), 1, + anon_sym_PIPE_GT, + ACTIONS(726), 1, + anon_sym_LBRACK2, + ACTIONS(728), 1, sym__call_open_gap, - anon_sym_DOT, + ACTIONS(730), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(710), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(720), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(718), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(818), 13, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31772,59 +33205,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29343] = 15, + [31328] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(701), 1, + ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(703), 1, + ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, + ACTIONS(716), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, + ACTIONS(722), 1, anon_sym_SLASH, - ACTIONS(713), 1, + ACTIONS(724), 1, anon_sym_PIPE_GT, - ACTIONS(715), 1, + ACTIONS(726), 1, anon_sym_LBRACK2, - ACTIONS(717), 1, + ACTIONS(728), 1, sym__call_open_gap, - ACTIONS(746), 1, + ACTIONS(730), 1, anon_sym_LBRACE, - ACTIONS(697), 2, + STATE(1644), 1, + sym__call_type_arguments, + ACTIONS(708), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(710), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, + ACTIONS(720), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(707), 4, + ACTIONS(718), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(673), 13, + ACTIONS(820), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31838,14 +33263,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29407] = 3, + [31398] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(675), 3, + ACTIONS(695), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(677), 29, + anon_sym_LT2, + ACTIONS(697), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -31875,43 +33301,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29447] = 15, + [31439] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(570), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(681), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(572), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31919,19 +33322,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29511] = 3, + [31480] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(549), 3, + ACTIONS(699), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(551), 29, + anon_sym_LT2, + ACTIONS(701), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -31961,14 +33377,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29551] = 3, + [31521] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(533), 3, + ACTIONS(614), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(535), 29, + anon_sym_LT2, + ACTIONS(617), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -31998,43 +33415,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29591] = 15, + [31562] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(620), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(749), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(622), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32042,68 +33436,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [29655] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(701), 1, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(751), 1, - anon_sym_LBRACE, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(494), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29719] = 3, + [31603] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(443), 3, + ACTIONS(624), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(445), 29, + anon_sym_LT2, + ACTIONS(626), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -32133,43 +33491,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29759] = 15, + [31644] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(628), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(451), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(631), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32177,19 +33512,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29823] = 3, + [31685] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(481), 3, + ACTIONS(634), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(483), 29, + anon_sym_LT2, + ACTIONS(636), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -32219,14 +33567,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29863] = 3, + [31726] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(545), 3, + ACTIONS(574), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(547), 29, + anon_sym_LT2, + ACTIONS(576), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -32256,14 +33605,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29903] = 3, + [31767] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(496), 3, + ACTIONS(638), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(498), 29, + anon_sym_LT2, + ACTIONS(640), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -32293,92 +33643,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29943] = 15, + [31808] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(642), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(754), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30007] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, + anon_sym_LT2, + ACTIONS(644), 29, sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(756), 13, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32386,97 +33664,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30071] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(758), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30135] = 15, + [31849] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(646), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(760), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(648), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32484,97 +33702,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30199] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(762), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30263] = 15, + [31890] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(578), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(764), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(580), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32582,97 +33740,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30327] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(766), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30391] = 15, + [31931] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(650), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(768), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(652), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32680,97 +33778,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30455] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(770), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30519] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + [31972] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(582), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(772), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(584), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32778,48 +33816,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30583] = 15, + [32013] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(654), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(774), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(656), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32827,48 +33854,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30647] = 15, + [32054] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(658), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(776), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(660), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32876,48 +33892,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30711] = 15, + [32095] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(586), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(778), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(588), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32925,48 +33930,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30775] = 15, + [32136] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(662), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(780), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(664), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32974,48 +33968,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30839] = 15, + [32177] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(590), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(782), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(592), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33023,48 +34006,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30903] = 15, + [32218] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(556), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(784), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(559), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33072,48 +34044,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30967] = 15, + [32259] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(548), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(786), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(550), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33121,48 +34082,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31031] = 15, + [32300] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(666), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(788), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(668), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33170,48 +34120,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31095] = 15, + [32341] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(670), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(790), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(672), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33219,48 +34158,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31159] = 15, + [32382] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(610), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(792), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(612), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33268,48 +34196,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31223] = 15, + [32423] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(674), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(794), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(676), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33317,48 +34234,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31287] = 15, + [32464] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(678), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(796), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(680), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33366,48 +34272,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31351] = 15, + [32505] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, + ACTIONS(562), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(564), 29, + sym__call_open_gap, anon_sym_DOT, - ACTIONS(695), 1, anon_sym_LBRACE, - ACTIONS(701), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(703), 1, anon_sym_PIPE_PIPE, - ACTIONS(705), 1, anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(798), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [32546] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(682), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(684), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33415,19 +34348,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31415] = 3, + [32587] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(525), 3, + ACTIONS(552), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(527), 29, + anon_sym_LT2, + ACTIONS(554), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33457,14 +34403,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31455] = 3, + [32628] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(485), 3, + ACTIONS(686), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(487), 29, + anon_sym_LT2, + ACTIONS(688), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33494,14 +34441,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31495] = 3, + [32669] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(401), 3, + ACTIONS(566), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(403), 29, + anon_sym_LT2, + ACTIONS(568), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33531,43 +34479,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31535] = 15, + [32710] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(598), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(800), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(600), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33575,48 +34500,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31599] = 15, + [32751] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(594), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(802), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(596), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33624,48 +34538,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31663] = 15, + [32792] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(693), 1, - anon_sym_DOT, - ACTIONS(695), 1, - anon_sym_LBRACE, - ACTIONS(701), 1, - anon_sym_QMARK, - ACTIONS(703), 1, - anon_sym_PIPE_PIPE, - ACTIONS(705), 1, - anon_sym_AMP_AMP, - ACTIONS(711), 1, - anon_sym_SLASH, - ACTIONS(713), 1, - anon_sym_PIPE_GT, - ACTIONS(715), 1, - anon_sym_LBRACK2, - ACTIONS(717), 1, - sym__call_open_gap, - ACTIONS(697), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(699), 2, + ACTIONS(407), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(709), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(707), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(804), 13, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(409), 29, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33673,19 +34576,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31727] = 3, + [32833] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(604), 3, + ACTIONS(602), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(607), 29, + anon_sym_LT2, + ACTIONS(604), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33715,14 +34631,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31767] = 3, + [32874] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(683), 3, + ACTIONS(606), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(685), 29, + anon_sym_LT2, + ACTIONS(608), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33752,46 +34669,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31807] = 16, + [32915] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(808), 1, + ACTIONS(824), 1, anon_sym_LBRACE, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(811), 3, + ACTIONS(827), 3, anon_sym_RBRACE, anon_sym_LPAREN, sym_float, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(806), 8, + ACTIONS(822), 8, anon_sym__, anon_sym_LBRACK, anon_sym_true, @@ -33800,46 +34721,50 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [31871] = 16, + [32985] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(815), 1, + ACTIONS(831), 1, anon_sym_LBRACE, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(818), 3, + ACTIONS(834), 3, anon_sym_RBRACE, anon_sym_LPAREN, sym_float, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(813), 8, + ACTIONS(829), 8, anon_sym__, anon_sym_LBRACK, anon_sym_true, @@ -33848,14 +34773,14 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [31935] = 5, + [33055] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(820), 1, + ACTIONS(836), 1, anon_sym_COLON_COLON, - STATE(389), 1, + STATE(396), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 9, + ACTIONS(425), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LT, @@ -33865,7 +34790,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_PLUS, sym__doc_comment_line, - ACTIONS(417), 18, + ACTIONS(423), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33884,14 +34809,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [31976] = 5, + [33096] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(823), 1, + ACTIONS(839), 1, anon_sym_COLON_COLON, - STATE(389), 1, + STATE(396), 1, aux_sym_qualified_path_repeat1, - ACTIONS(415), 8, + ACTIONS(421), 8, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LT, @@ -33900,7 +34825,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_LBRACK, sym__doc_comment_line, - ACTIONS(413), 18, + ACTIONS(419), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33919,10 +34844,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [32016] = 3, + [33136] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(419), 10, + ACTIONS(425), 10, anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33933,7 +34858,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_PLUS, sym__doc_comment_line, - ACTIONS(417), 18, + ACTIONS(423), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33952,42 +34877,81 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [32052] = 17, + [33172] = 10, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(841), 1, + anon_sym_COLON_COLON, + ACTIONS(843), 1, + anon_sym_LBRACE, + ACTIONS(846), 1, + anon_sym_COLON, + ACTIONS(849), 1, + anon_sym_EQ, + STATE(438), 1, + aux_sym_qualified_path_repeat1, + STATE(1554), 1, + sym_type_arguments, + ACTIONS(407), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(409), 17, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33221] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(825), 1, + ACTIONS(851), 1, anon_sym_RBRACE, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(412), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -33997,42 +34961,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32114] = 17, + [33283] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(847), 1, + ACTIONS(873), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(398), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34042,42 +35006,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32176] = 17, + [33345] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(849), 1, + ACTIONS(875), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(436), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34087,42 +35051,78 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32238] = 17, + [33407] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(841), 1, + anon_sym_COLON_COLON, + ACTIONS(843), 1, + anon_sym_LBRACE, + STATE(438), 1, + aux_sym_qualified_path_repeat1, + STATE(1554), 1, + sym_type_arguments, + ACTIONS(407), 4, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(409), 17, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33451] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(851), 1, + ACTIONS(877), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(400), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34132,42 +35132,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32300] = 17, + [33513] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(853), 1, + ACTIONS(879), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(410), 2, + STATE(417), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34177,42 +35177,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32362] = 17, + [33575] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(855), 1, + ACTIONS(881), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34222,42 +35222,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32424] = 17, + [33637] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(857), 1, + ACTIONS(883), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34267,42 +35267,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32486] = 17, + [33699] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(859), 1, + ACTIONS(885), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(401), 2, + STATE(407), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34312,42 +35312,116 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32548] = 17, + [33761] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(411), 1, + anon_sym_COLON_COLON, + ACTIONS(413), 1, + anon_sym_LBRACE, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(887), 1, + anon_sym_COLON, + STATE(231), 1, + aux_sym_qualified_path_repeat1, + STATE(1680), 1, + sym_type_arguments, + ACTIONS(407), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(409), 17, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33807] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(841), 1, + anon_sym_COLON_COLON, + ACTIONS(843), 1, + anon_sym_LBRACE, + ACTIONS(849), 1, + anon_sym_EQ, + STATE(438), 1, + aux_sym_qualified_path_repeat1, + STATE(1554), 1, + sym_type_arguments, + ACTIONS(407), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(409), 17, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33853] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(861), 1, + ACTIONS(889), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34357,42 +35431,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32610] = 17, + [33915] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(863), 1, + ACTIONS(891), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(420), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34402,42 +35476,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32672] = 17, + [33977] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(893), 1, + anon_sym_RBRACE, + ACTIONS(898), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(901), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(904), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(907), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(910), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(913), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(916), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(919), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(922), 1, anon_sym_signature, - ACTIONS(865), 1, - anon_sym_RBRACE, - STATE(224), 1, + ACTIONS(925), 1, + sym__doc_comment_line, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(895), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34447,42 +35521,81 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32734] = 17, + [34039] = 11, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(411), 1, + anon_sym_COLON_COLON, + ACTIONS(413), 1, + anon_sym_LBRACE, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(928), 1, + anon_sym_RBRACE, + ACTIONS(931), 1, + anon_sym_COMMA, + STATE(231), 1, + aux_sym_qualified_path_repeat1, + STATE(1124), 1, + aux_sym_field_pattern_repeat1, + STATE(1680), 1, + sym_type_arguments, + ACTIONS(407), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(409), 15, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [34089] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(867), 1, + ACTIONS(933), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(402), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34492,42 +35605,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32796] = 17, + [34151] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(869), 1, + ACTIONS(935), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(401), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34537,42 +35650,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32858] = 17, + [34213] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, - anon_sym_signature, ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(937), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(397), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34582,42 +35695,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32920] = 17, + [34275] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(873), 1, + ACTIONS(939), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(406), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34627,42 +35740,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [32982] = 17, + [34337] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(875), 1, + ACTIONS(941), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(394), 2, + STATE(404), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34672,42 +35785,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33044] = 17, + [34399] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(877), 1, - anon_sym_RBRACE, - ACTIONS(882), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(885), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(888), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(891), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(894), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(897), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(900), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(903), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(906), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(909), 1, - sym__doc_comment_line, - STATE(224), 1, + ACTIONS(943), 1, + anon_sym_RBRACE, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(879), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34717,42 +35830,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33106] = 17, + [34461] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(912), 1, + ACTIONS(945), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(415), 2, + STATE(423), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34762,42 +35875,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33168] = 17, + [34523] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(914), 1, + ACTIONS(947), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(426), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34807,42 +35920,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33230] = 17, + [34585] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(916), 1, + ACTIONS(949), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34852,42 +35965,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33292] = 17, + [34647] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(918), 1, + ACTIONS(951), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(400), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34897,42 +36010,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33354] = 17, + [34709] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(920), 1, + ACTIONS(953), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(429), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34942,42 +36055,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33416] = 17, + [34771] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(922), 1, + ACTIONS(955), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(421), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34987,42 +36100,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33478] = 17, + [34833] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(924), 1, + ACTIONS(957), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(431), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35032,42 +36145,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33540] = 17, + [34895] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(926), 1, + ACTIONS(959), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(432), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35077,42 +36190,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33602] = 17, + [34957] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(928), 1, + ACTIONS(961), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(406), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35122,42 +36235,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33664] = 17, + [35019] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(930), 1, + ACTIONS(963), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(425), 2, + STATE(434), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35167,80 +36280,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33726] = 10, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(932), 1, - anon_sym_COLON_COLON, - ACTIONS(934), 1, - anon_sym_LBRACE, - ACTIONS(937), 1, - anon_sym_COLON, - ACTIONS(940), 1, - anon_sym_EQ, - STATE(431), 1, - aux_sym_qualified_path_repeat1, - STATE(1461), 1, - sym_type_arguments, - ACTIONS(401), 2, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(403), 17, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [33774] = 17, + [35081] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(942), 1, + ACTIONS(965), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(424), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35250,42 +36325,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33836] = 17, + [35143] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(944), 1, + ACTIONS(967), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35295,42 +36370,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33898] = 17, + [35205] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(946), 1, + ACTIONS(969), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(411), 2, + STATE(435), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35340,42 +36415,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33960] = 17, + [35267] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(948), 1, + ACTIONS(971), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(404), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35385,42 +36460,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34022] = 17, + [35329] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(950), 1, + ACTIONS(973), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35430,42 +36505,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34084] = 17, + [35391] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(829), 1, + ACTIONS(855), 1, anon_sym_fn, - ACTIONS(831), 1, + ACTIONS(857), 1, anon_sym_extern, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(839), 1, + ACTIONS(865), 1, anon_sym_state, - ACTIONS(841), 1, + ACTIONS(867), 1, anon_sym_module, - ACTIONS(843), 1, + ACTIONS(869), 1, anon_sym_export, - ACTIONS(845), 1, + ACTIONS(871), 1, anon_sym_signature, - ACTIONS(952), 1, + ACTIONS(975), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(795), 1, + STATE(820), 1, sym_doc_comment, - ACTIONS(827), 2, + ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(408), 2, + STATE(413), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(708), 9, + STATE(758), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35475,27 +36550,24 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34146] = 8, + [35453] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(932), 1, + ACTIONS(977), 1, anon_sym_COLON_COLON, - ACTIONS(934), 1, - anon_sym_LBRACE, - STATE(431), 1, + STATE(437), 1, aux_sym_qualified_path_repeat1, - STATE(1461), 1, - sym_type_arguments, - ACTIONS(401), 3, + ACTIONS(423), 5, anon_sym_COLON, + anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(403), 17, + anon_sym_LT2, + ACTIONS(425), 18, sym__call_open_gap, sym__statement_break, anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_QMARK, @@ -35510,31 +36582,25 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [34189] = 11, + [35490] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(405), 1, + ACTIONS(841), 1, anon_sym_COLON_COLON, - ACTIONS(407), 1, - anon_sym_LBRACE, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(954), 1, - anon_sym_RBRACE, - ACTIONS(957), 1, - anon_sym_COMMA, - STATE(228), 1, + STATE(437), 1, aux_sym_qualified_path_repeat1, - STATE(1243), 1, - aux_sym_field_pattern_repeat1, - STATE(1654), 1, - sym_type_arguments, - ACTIONS(401), 2, + ACTIONS(419), 5, + anon_sym_COLON, + anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(403), 15, + anon_sym_LT2, + ACTIONS(421), 18, sym__call_open_gap, + sym__statement_break, anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_STAR, anon_sym_QMARK, anon_sym_PIPE_PIPE, @@ -35548,22 +36614,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [34238] = 7, + [35527] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(823), 1, + ACTIONS(839), 1, anon_sym_COLON_COLON, - ACTIONS(963), 1, + ACTIONS(984), 1, anon_sym_LT, - ACTIONS(965), 1, + ACTIONS(986), 1, anon_sym_LBRACK, - STATE(390), 1, + STATE(397), 1, aux_sym_qualified_path_repeat1, - ACTIONS(961), 3, + ACTIONS(982), 3, anon_sym_RBRACE, anon_sym_BANG, sym__doc_comment_line, - ACTIONS(959), 18, + ACTIONS(980), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35582,94 +36648,108 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [34279] = 9, + [35568] = 19, + ACTIONS(131), 1, + anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(932), 1, - anon_sym_COLON_COLON, - ACTIONS(934), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(940), 1, - anon_sym_EQ, - STATE(431), 1, - aux_sym_qualified_path_repeat1, - STATE(1461), 1, - sym_type_arguments, - ACTIONS(401), 2, - anon_sym_GT, + ACTIONS(994), 1, + anon_sym_COLON, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(403), 17, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + ACTIONS(1016), 1, sym__statement_break, - anon_sym_DOT, - anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34324] = 9, + [35632] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(405), 1, - anon_sym_COLON_COLON, - ACTIONS(407), 1, - anon_sym_LBRACE, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(967), 1, - anon_sym_COLON, - STATE(228), 1, - aux_sym_qualified_path_repeat1, - STATE(1654), 1, - sym_type_arguments, - ACTIONS(401), 2, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(403), 17, - sym__call_open_gap, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_RPAREN, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, anon_sym_QMARK, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(479), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34369] = 5, + [35692] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(932), 1, - anon_sym_COLON_COLON, - STATE(432), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(413), 4, + ACTIONS(423), 5, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(415), 18, + anon_sym_LT2, + ACTIONS(425), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -35685,327 +36765,459 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [34405] = 5, + [35724] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(969), 1, - anon_sym_COLON_COLON, - STATE(432), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(417), 4, - anon_sym_COLON, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(419), 18, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + ACTIONS(1018), 1, + anon_sym_LBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(475), 3, sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [35784] = 19, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, + ACTIONS(442), 1, anon_sym_QMARK, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, + ACTIONS(446), 1, anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(1023), 1, + anon_sym_RPAREN, + STATE(1216), 1, + aux_sym_argument_list_repeat1, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + [35848] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1025), 1, + anon_sym_LBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PERCENT, + ACTIONS(527), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [35908] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, anon_sym_PIPE_GT, + ACTIONS(1012), 1, anon_sym_LBRACK2, - [34441] = 6, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(483), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [35968] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(410), 1, - anon_sym_LT, - ACTIONS(972), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, anon_sym_LBRACE, - STATE(1461), 1, - sym_type_arguments, - ACTIONS(401), 2, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(403), 18, - sym__call_open_gap, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(495), 3, sym__statement_break, - anon_sym_DOT, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34478] = 3, + [36028] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(417), 4, - anon_sym_COLON, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(419), 19, - sym__call_open_gap, - sym__statement_break, + ACTIONS(432), 1, anon_sym_DOT, - anon_sym_COLON_COLON, + ACTIONS(434), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, + ACTIONS(442), 1, anon_sym_QMARK, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, + ACTIONS(446), 1, anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1028), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34509] = 15, + [36088] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(975), 1, - sym_identifier, - ACTIONS(977), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1030), 1, anon_sym_LBRACE, - ACTIONS(979), 1, - anon_sym_RBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - STATE(1700), 1, - sym_field_pattern, - ACTIONS(987), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(505), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [34564] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(975), 1, - sym_identifier, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(993), 1, + ACTIONS(534), 3, + sym__statement_break, anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - STATE(1700), 1, - sym_field_pattern, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(454), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [34619] = 15, + anon_sym_COLON, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [36148] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(975), 1, - sym_identifier, - ACTIONS(977), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(995), 1, - anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - STATE(1700), 1, - sym_field_pattern, - ACTIONS(987), 2, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(511), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [34674] = 5, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(963), 1, - anon_sym_LT, - ACTIONS(965), 1, - anon_sym_LBRACK, - ACTIONS(961), 3, + ACTIONS(487), 3, + sym__statement_break, anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(959), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [34709] = 7, + anon_sym_COLON, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [36208] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(427), 3, + ACTIONS(1033), 1, + anon_sym_LBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(431), 15, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(509), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - [34747] = 15, + [36268] = 19, + ACTIONS(240), 1, + anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(994), 1, + anon_sym_COLON, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(451), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [34801] = 3, + [36332] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(481), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(540), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(483), 19, - sym__call_open_gap, + ACTIONS(542), 16, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -36021,214 +37233,281 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34831] = 3, + [36374] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(529), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(531), 19, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(517), 4, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34861] = 10, + [36432] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(427), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1007), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1019), 2, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(431), 11, + ACTIONS(464), 4, sym__statement_break, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [34905] = 12, + [36490] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(513), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(431), 6, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - [34953] = 11, + [36550] = 19, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, + anon_sym_COMMA, + ACTIONS(1036), 1, + anon_sym_RBRACK, + STATE(1231), 1, + aux_sym_argument_list_repeat1, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(431), 7, - sym__statement_break, + [36614] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(998), 1, anon_sym_QMARK, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - [34999] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(427), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1007), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(431), 13, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(538), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - [35041] = 6, + [36674] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(1001), 1, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(537), 3, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(539), 16, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(436), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - [35077] = 3, + [36734] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(541), 3, + ACTIONS(416), 1, + anon_sym_LT2, + ACTIONS(1038), 1, + anon_sym_LBRACE, + STATE(1554), 1, + sym_type_arguments, + ACTIONS(407), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(543), 19, + ACTIONS(409), 18, sym__call_open_gap, sym__statement_break, anon_sym_DOT, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_COLON, @@ -36244,122 +37523,203 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35107] = 3, + [36772] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(683), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(685), 19, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, + ACTIONS(1041), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(502), 3, + sym__statement_break, + anon_sym_RBRACE, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35137] = 15, + [36832] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1011), 1, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1023), 1, - anon_sym_LBRACE, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(558), 3, + ACTIONS(546), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35191] = 15, + [36892] = 19, + ACTIONS(248), 1, + anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(994), 1, + anon_sym_COLON, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(1016), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [36956] = 19, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(1044), 1, + anon_sym_RBRACK, + STATE(1180), 1, + aux_sym_argument_list_repeat1, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1026), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35245] = 3, + [37020] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(560), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(466), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(562), 19, - sym__call_open_gap, + ACTIONS(468), 15, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -36374,22 +37734,36 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35275] = 3, + [37064] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(564), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(566), 19, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(466), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(468), 11, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, @@ -36398,90 +37772,157 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35305] = 14, + [37114] = 19, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1030), 1, - anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - ACTIONS(987), 2, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(1046), 1, + anon_sym_RBRACK, + STATE(1164), 1, + aux_sym_argument_list_repeat1, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(481), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [35357] = 3, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [37178] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(604), 3, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(468), 6, + sym__statement_break, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + [37232] = 13, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(607), 19, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(468), 7, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35387] = 3, + [37284] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(485), 3, - anon_sym_LT, - anon_sym_GT, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(487), 19, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(466), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(468), 13, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, @@ -36492,61 +37933,25 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35417] = 17, - ACTIONS(184), 1, - anon_sym_RBRACE, + [37332] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1032), 1, - anon_sym_COLON, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35475] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(401), 3, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(489), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(403), 19, - sym__call_open_gap, + ACTIONS(491), 16, sym__statement_break, - anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -36562,54 +37967,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [35505] = 15, + [37374] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(570), 3, - sym__statement_break, + ACTIONS(1048), 2, anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, + anon_sym_COMMA, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35559] = 3, + [37433] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(572), 3, + ACTIONS(552), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(574), 19, + anon_sym_LT2, + ACTIONS(554), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36629,52 +38037,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35589] = 14, + [37464] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1036), 1, - sym_identifier, - ACTIONS(1039), 1, - anon_sym_LBRACE, - ACTIONS(1042), 1, - anon_sym_RBRACE, - ACTIONS(1044), 1, - anon_sym_LPAREN, - ACTIONS(1050), 1, - anon_sym_LBRACK, - ACTIONS(1059), 1, - sym_float, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(1053), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1056), 2, - anon_sym_true, - anon_sym_false, - STATE(461), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(1047), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [35641] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(576), 3, + ACTIONS(654), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(579), 19, + anon_sym_LT2, + ACTIONS(656), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36694,14 +38065,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35671] = 3, + [37495] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(545), 3, + ACTIONS(695), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(547), 19, + anon_sym_LT2, + ACTIONS(697), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36721,14 +38093,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35701] = 3, + [37526] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 3, + ACTIONS(658), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(584), 19, + anon_sym_LT2, + ACTIONS(660), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36748,14 +38121,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35731] = 3, + [37557] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(586), 3, + ACTIONS(610), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(588), 19, + anon_sym_LT2, + ACTIONS(612), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36775,53 +38149,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35761] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(829), 1, - anon_sym_fn, - ACTIONS(831), 1, - anon_sym_extern, - ACTIONS(833), 1, - anon_sym_type, - ACTIONS(835), 1, - sym_static_stage, - ACTIONS(837), 1, - anon_sym_effect, - ACTIONS(839), 1, - anon_sym_state, - ACTIONS(841), 1, - anon_sym_module, - ACTIONS(845), 1, - anon_sym_signature, - ACTIONS(1062), 1, - anon_sym_opaque, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(827), 2, - anon_sym_let, - anon_sym_mut, - STATE(698), 8, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym__module_declaration, - sym_signature_declaration, - [35815] = 3, + [37588] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(590), 3, + ACTIONS(598), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(593), 19, + anon_sym_LT2, + ACTIONS(600), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36841,14 +38177,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35845] = 3, + [37619] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(596), 3, + ACTIONS(562), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(598), 19, + anon_sym_LT2, + ACTIONS(564), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36868,100 +38205,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35875] = 17, + [37650] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, - anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(1066), 1, - anon_sym_RPAREN, - STATE(1147), 1, - aux_sym_argument_list_repeat1, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(638), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35933] = 14, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(602), 4, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35985] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, + anon_sym_LT2, + ACTIONS(640), 19, sym__call_open_gap, - ACTIONS(465), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(467), 16, sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -36977,14 +38232,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - [36021] = 3, + anon_sym_LBRACK2, + [37681] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(610), 3, + ACTIONS(662), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(612), 19, + anon_sym_LT2, + ACTIONS(664), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37004,14 +38261,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36051] = 3, + [37712] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(614), 3, + ACTIONS(642), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(616), 19, + anon_sym_LT2, + ACTIONS(644), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37031,14 +38289,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36081] = 3, + [37743] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(469), 3, + ACTIONS(699), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(471), 19, + anon_sym_LT2, + ACTIONS(701), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37058,94 +38317,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36111] = 17, + [37774] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(586), 4, + anon_sym_LT, + anon_sym_GT, anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + anon_sym_LT2, + ACTIONS(588), 19, sym__call_open_gap, - ACTIONS(449), 1, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(1068), 1, - anon_sym_RBRACK, - STATE(1180), 1, - aux_sym_argument_list_repeat1, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36169] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1070), 1, - anon_sym_LBRACE, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(623), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36223] = 3, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [37805] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(496), 3, + ACTIONS(614), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(498), 19, + anon_sym_LT2, + ACTIONS(617), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37165,14 +38373,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36253] = 3, + [37836] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(500), 3, + ACTIONS(646), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(502), 19, + anon_sym_LT2, + ACTIONS(648), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37192,14 +38401,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36283] = 3, + [37867] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(504), 3, + ACTIONS(670), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(506), 19, + anon_sym_LT2, + ACTIONS(672), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37219,14 +38429,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36313] = 3, + [37898] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(625), 3, + ACTIONS(582), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(627), 19, + anon_sym_LT2, + ACTIONS(584), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37246,52 +38457,98 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36343] = 14, + [37929] = 18, + ACTIONS(244), 1, + anon_sym_RBRACE, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [37990] = 15, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1073), 1, + ACTIONS(1050), 1, sym_identifier, - ACTIONS(1076), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(1079), 1, + ACTIONS(1054), 1, anon_sym_RBRACE, - ACTIONS(1081), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - ACTIONS(1087), 1, + ACTIONS(1060), 1, anon_sym_LBRACK, - ACTIONS(1096), 1, + ACTIONS(1066), 1, sym_float, - STATE(1267), 1, + STATE(1332), 1, sym_qualified_path, - STATE(1390), 1, + STATE(1360), 1, + sym_field_pattern, + STATE(1507), 1, sym_pattern, - ACTIONS(1090), 2, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1093), 2, + ACTIONS(1064), 2, anon_sym_true, anon_sym_false, - STATE(481), 2, + STATE(594), 2, sym_match_arm, aux_sym_match_expression_repeat1, - ACTIONS(1084), 4, + ACTIONS(1058), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1091), 4, + STATE(1112), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [36395] = 3, + [38045] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(508), 3, + ACTIONS(566), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(510), 19, + anon_sym_LT2, + ACTIONS(568), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37311,53 +38568,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36425] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(829), 1, - anon_sym_fn, - ACTIONS(831), 1, - anon_sym_extern, - ACTIONS(833), 1, - anon_sym_type, - ACTIONS(835), 1, - sym_static_stage, - ACTIONS(837), 1, - anon_sym_effect, - ACTIONS(839), 1, - anon_sym_state, - ACTIONS(841), 1, - anon_sym_module, - ACTIONS(845), 1, - anon_sym_signature, - ACTIONS(1099), 1, - anon_sym_opaque, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(827), 2, - anon_sym_let, - anon_sym_mut, - STATE(721), 8, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym__module_declaration, - sym_signature_declaration, - [36479] = 3, + [38076] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(633), 3, + ACTIONS(620), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(635), 19, + anon_sym_LT2, + ACTIONS(622), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37377,14 +38596,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36509] = 3, + [38107] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(637), 3, + ACTIONS(407), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(639), 19, + anon_sym_LT2, + ACTIONS(409), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37404,91 +38624,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36539] = 14, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(643), 4, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36591] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1101), 1, - anon_sym_LBRACE, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(650), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36645] = 3, + [38138] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(512), 3, + ACTIONS(570), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(514), 19, + anon_sym_LT2, + ACTIONS(572), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37508,14 +38652,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36675] = 3, + [38169] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(525), 3, + ACTIONS(574), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(527), 19, + anon_sym_LT2, + ACTIONS(576), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37535,158 +38680,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36705] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(475), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36759] = 15, + [38200] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(654), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36813] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(658), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36867] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(660), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(662), 19, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_LBRACE, + ACTIONS(1068), 2, anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_COMMA, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [36897] = 3, + [38259] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(664), 3, + ACTIONS(624), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(666), 19, + anon_sym_LT2, + ACTIONS(626), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37706,196 +38750,85 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [36927] = 15, + [38290] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(479), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [36981] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1104), 1, - anon_sym_LBRACE, - ACTIONS(1007), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(673), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1017), 4, + ACTIONS(1070), 2, + anon_sym_in, + sym_identifier, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37035] = 14, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1107), 1, - anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(461), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [37087] = 3, + [38349] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(675), 3, + ACTIONS(650), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(677), 19, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37117] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, + anon_sym_LT2, + ACTIONS(652), 19, sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(681), 3, sym__statement_break, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COLON, - ACTIONS(1017), 4, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37171] = 3, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [38380] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(549), 3, + ACTIONS(674), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(551), 19, + anon_sym_LT2, + ACTIONS(676), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37915,14 +38848,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37201] = 3, + [38411] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(533), 3, + ACTIONS(678), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(535), 19, + anon_sym_LT2, + ACTIONS(680), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -37942,172 +38876,255 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37231] = 17, - ACTIONS(192), 1, - anon_sym_RBRACE, + [38442] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1032), 1, - anon_sym_COLON, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1072), 2, + anon_sym_in, + sym_identifier, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37289] = 17, + [38501] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(984), 1, + anon_sym_LT, + ACTIONS(986), 1, + anon_sym_LBRACK, + ACTIONS(982), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(980), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [38536] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(1109), 1, - anon_sym_RBRACK, - STATE(1156), 1, - aux_sym_argument_list_repeat1, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + ACTIONS(1074), 1, + anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37347] = 14, + [38597] = 15, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(1050), 1, + sym_identifier, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(981), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - ACTIONS(985), 1, + ACTIONS(1060), 1, anon_sym_LBRACK, - ACTIONS(991), 1, + ACTIONS(1066), 1, sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1111), 1, + ACTIONS(1076), 1, anon_sym_RBRACE, - STATE(1267), 1, + STATE(1332), 1, sym_qualified_path, - STATE(1504), 1, + STATE(1360), 1, + sym_field_pattern, + STATE(1507), 1, sym_pattern, - ACTIONS(987), 2, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, + ACTIONS(1064), 2, anon_sym_true, anon_sym_false, - STATE(461), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, + STATE(551), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1058), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1091), 4, + STATE(1112), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [37399] = 14, + [38652] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1078), 2, + anon_sym_in, sym_identifier, - ACTIONS(1113), 1, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [38711] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, + anon_sym_DOT, + ACTIONS(990), 1, + anon_sym_LBRACE, + ACTIONS(998), 1, + anon_sym_QMARK, + ACTIONS(1000), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1002), 1, + anon_sym_AMP_AMP, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + ACTIONS(1080), 1, anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - ACTIONS(987), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(996), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(481), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [37451] = 3, + ACTIONS(1004), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [38772] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(521), 3, + ACTIONS(548), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(523), 19, + anon_sym_LT2, + ACTIONS(550), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38127,211 +39144,184 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37481] = 15, + [38803] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(666), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(668), 19, sym__call_open_gap, - ACTIONS(1011), 1, + sym__statement_break, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1013), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1115), 1, - anon_sym_LBRACE, - ACTIONS(1007), 2, - anon_sym_STAR, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_PERCENT, - ACTIONS(1009), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [38834] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(606), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(494), 3, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(608), 19, + sym__call_open_gap, sym__statement_break, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COLON, - ACTIONS(1017), 4, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37535] = 17, - ACTIONS(248), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [38865] = 18, + ACTIONS(242), 1, anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1032), 1, - anon_sym_COLON, - ACTIONS(1034), 1, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, sym__statement_break, - ACTIONS(1007), 2, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37593] = 17, + [38926] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(1118), 1, - anon_sym_RBRACK, - STATE(1202), 1, - aux_sym_argument_list_repeat1, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1082), 2, + anon_sym_in, + sym_identifier, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37651] = 14, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1120), 1, - anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(461), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [37703] = 14, + [38985] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(628), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(631), 19, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1122), 1, anon_sym_RBRACE, - STATE(1267), 1, - sym_qualified_path, - STATE(1390), 1, - sym_pattern, - ACTIONS(987), 2, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(481), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [37755] = 3, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39016] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(443), 3, + ACTIONS(556), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(445), 19, + anon_sym_LT2, + ACTIONS(559), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38351,60 +39341,78 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37785] = 15, + [39047] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(682), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(684), 19, sym__call_open_gap, - ACTIONS(1005), 1, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1011), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1013), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_PERCENT, - ACTIONS(1009), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39078] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(578), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(631), 3, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(580), 19, + sym__call_open_gap, sym__statement_break, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COLON, - ACTIONS(1017), 4, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37839] = 4, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39109] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1124), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - ACTIONS(485), 3, + ACTIONS(590), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(487), 16, + anon_sym_LT2, + ACTIONS(592), 19, sym__call_open_gap, + sym__statement_break, anon_sym_DOT, anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -38417,3716 +39425,4103 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37870] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1128), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1126), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [37899] = 15, + [39140] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1130), 2, - anon_sym_RBRACE, + ACTIONS(1084), 2, anon_sym_COMMA, - ACTIONS(461), 4, + anon_sym_RPAREN, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37952] = 15, + [39199] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + ACTIONS(1086), 1, + anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1132), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38005] = 8, - ACTIONS(3), 1, + [39260] = 15, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(823), 1, - anon_sym_COLON_COLON, - ACTIONS(963), 1, - anon_sym_LT, - ACTIONS(965), 1, - anon_sym_LBRACK, - ACTIONS(1134), 1, + ACTIONS(1050), 1, + sym_identifier, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(1138), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - STATE(390), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1136), 15, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1088), 1, anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [38044] = 15, + STATE(1332), 1, + sym_qualified_path, + STATE(1360), 1, + sym_field_pattern, + STATE(1507), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(580), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [39315] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1140), 2, - anon_sym_in, - sym_identifier, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [38097] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(1010), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(1014), 1, sym__call_open_gap, - ACTIONS(449), 1, - anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(1016), 1, + sym__statement_break, + ACTIONS(1090), 1, + anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1142), 2, - anon_sym_in, - sym_identifier, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38150] = 15, + [39376] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + ACTIONS(1092), 1, + anon_sym_RBRACE, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1144), 2, - anon_sym_in, - sym_identifier, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38203] = 16, + [39437] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(686), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(688), 19, sym__call_open_gap, - ACTIONS(1005), 1, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1011), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1013), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1146), 1, - anon_sym_RBRACE, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1017), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38258] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(1001), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + [39468] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(634), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(636), 19, sym__call_open_gap, - ACTIONS(1005), 1, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1011), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1013), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1148), 1, - anon_sym_RBRACE, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1017), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, - anon_sym_GT_EQ, - [38313] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(497), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [38362] = 15, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39499] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(594), 4, + anon_sym_LT, + anon_sym_GT, anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + anon_sym_LT2, + ACTIONS(596), 19, sym__call_open_gap, - ACTIONS(449), 1, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1150), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38415] = 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39530] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(602), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(604), 19, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(987), 2, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(510), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [38464] = 16, - ACTIONS(250), 1, - anon_sym_RBRACE, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39561] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(770), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38519] = 16, - ACTIONS(246), 1, - anon_sym_RBRACE, + [39619] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(805), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38574] = 15, + [39677] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(784), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1152), 2, - anon_sym_in, - sym_identifier, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38627] = 16, + [39735] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1154), 1, - anon_sym_RBRACE, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1094), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38682] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1158), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1156), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [38711] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1162), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1160), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [38740] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1166), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1164), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [38769] = 16, + [39793] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(820), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1168), 1, - anon_sym_RBRACE, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38824] = 16, + [39851] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(774), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1170), 1, - anon_sym_RBRACE, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38879] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - STATE(1267), 1, - sym_qualified_path, - STATE(1504), 1, - sym_pattern, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - STATE(504), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [38928] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1174), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1172), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [38957] = 15, + [39909] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1176), 1, - anon_sym_COLON, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1016), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39009] = 15, + [39967] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(794), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(750), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39061] = 15, + [40025] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(762), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(776), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39113] = 15, + [40083] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(786), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1178), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39165] = 15, + [40141] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(721), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(732), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39217] = 15, + [40199] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(766), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(1096), 1, + sym_identifier, + ACTIONS(1099), 1, + anon_sym_LBRACE, + ACTIONS(1102), 1, + anon_sym_RBRACE, + ACTIONS(1104), 1, + anon_sym_LPAREN, + ACTIONS(1110), 1, + anon_sym_LBRACK, + ACTIONS(1119), 1, + sym_float, + STATE(1332), 1, + sym_qualified_path, + STATE(1507), 1, + sym_pattern, + ACTIONS(1113), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1116), 2, + anon_sym_true, + anon_sym_false, + STATE(538), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1107), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [40251] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1122), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39269] = 15, + [40309] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(768), 1, + ACTIONS(1124), 1, + sym_identifier, + ACTIONS(1127), 1, + anon_sym_LBRACE, + ACTIONS(1130), 1, + anon_sym_RBRACE, + ACTIONS(1132), 1, + anon_sym_LPAREN, + ACTIONS(1138), 1, + anon_sym_LBRACK, + ACTIONS(1147), 1, + sym_float, + STATE(1332), 1, + sym_qualified_path, + STATE(1599), 1, + sym_pattern, + ACTIONS(1141), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1144), 2, + anon_sym_true, + anon_sym_false, + STATE(540), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1135), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [40361] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(797), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39321] = 15, + [40419] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1180), 1, - anon_sym_RBRACK, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1150), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39373] = 13, + [40477] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(981), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - ACTIONS(985), 1, + ACTIONS(1060), 1, anon_sym_LBRACK, - ACTIONS(991), 1, + ACTIONS(1066), 1, sym_float, - ACTIONS(1028), 1, + ACTIONS(1152), 1, sym_identifier, - ACTIONS(1182), 1, - anon_sym_DOT_DOT_DOT, - STATE(1259), 1, - sym_pattern, - STATE(1267), 1, + ACTIONS(1154), 1, + anon_sym_RBRACE, + STATE(1332), 1, sym_qualified_path, - ACTIONS(987), 2, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, + ACTIONS(1064), 2, anon_sym_true, anon_sym_false, - ACTIONS(983), 4, + STATE(540), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1091), 4, + STATE(1112), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [39421] = 15, + [40529] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1184), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1156), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39473] = 15, + [40587] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(772), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1009), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1019), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1017), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [39525] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(774), 1, - sym__statement_break, - ACTIONS(997), 1, - anon_sym_DOT, - ACTIONS(999), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1001), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1003), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, - anon_sym_QMARK, - ACTIONS(1013), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, - anon_sym_AMP_AMP, - ACTIONS(1021), 1, - anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1158), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39577] = 15, + [40645] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(776), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1160), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39629] = 15, + [40703] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(1162), 1, + anon_sym_opaque, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(828), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(696), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [40757] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(778), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1164), 1, + anon_sym_COLON, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39681] = 15, + [40815] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(737), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1166), 1, + anon_sym_RBRACK, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39733] = 15, + [40873] = 17, ACTIONS(298), 1, - sym_line_comment, - ACTIONS(790), 1, - sym__statement_break, - ACTIONS(997), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1168), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39785] = 15, + [40931] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(792), 1, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1170), 1, + anon_sym_RBRACE, + STATE(1332), 1, + sym_qualified_path, + STATE(1507), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(538), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [40983] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(734), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39837] = 15, + [41041] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(796), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1172), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39889] = 15, + [41099] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(782), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(816), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39941] = 15, + [41157] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(784), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(778), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39993] = 15, + [41215] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1186), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1174), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40045] = 15, + [41273] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(786), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(788), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40097] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1188), 1, - anon_sym_DOT_DOT_DOT, - STATE(1259), 1, - sym_pattern, - STATE(1267), 1, - sym_qualified_path, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [40145] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1190), 1, - anon_sym_COLON_COLON, - STATE(561), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(417), 4, - anon_sym_COLON, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(419), 14, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - anon_sym_PLUS, - [40177] = 15, + [41331] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(788), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1176), 1, + anon_sym_COMMA, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40229] = 15, + [41389] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(739), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(780), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40281] = 15, + [41447] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1193), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1178), 1, anon_sym_COLON, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40333] = 15, + [41505] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1195), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1180), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40385] = 15, + [41563] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(798), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1182), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40437] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, - sym_identifier, - ACTIONS(1197), 1, - anon_sym_RBRACK, - STATE(1194), 1, - sym_pattern, - STATE(1267), 1, - sym_qualified_path, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [40485] = 15, + [41621] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(800), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1184), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40537] = 15, + [41679] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(802), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(736), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40589] = 15, + [41737] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(790), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1032), 1, - anon_sym_COLON, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40641] = 15, + [41795] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(804), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1186), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40693] = 15, + [41853] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(749), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(772), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40745] = 15, + [41911] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(741), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1188), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40797] = 15, + [41969] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(756), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(740), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40849] = 15, + [42027] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(742), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1199), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40901] = 15, + [42085] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1201), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(994), 1, + anon_sym_COLON, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40953] = 15, + [42143] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1190), 1, + anon_sym_RBRACE, + STATE(1332), 1, + sym_qualified_path, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(540), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [42195] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1203), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1192), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41005] = 15, + [42253] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1205), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1194), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41057] = 15, + [42311] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1207), 1, - anon_sym_COMMA, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1196), 1, + anon_sym_RPAREN, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41109] = 15, + [42369] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1209), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1198), 1, anon_sym_COLON, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41161] = 15, + [42427] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1211), 1, - anon_sym_RBRACK, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1200), 1, + anon_sym_COLON, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41213] = 15, + [42485] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(754), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1202), 1, + anon_sym_RBRACK, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41265] = 15, + [42543] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(760), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(744), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41317] = 15, + [42601] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1204), 1, + anon_sym_RBRACE, + STATE(1332), 1, + sym_qualified_path, + STATE(1507), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(538), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [42653] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1213), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1206), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41369] = 15, + [42711] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1208), 1, + anon_sym_RBRACE, + STATE(1332), 1, + sym_qualified_path, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(540), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [42763] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1215), 1, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1210), 1, anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41421] = 15, + [42821] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1217), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1212), 1, + anon_sym_COLON, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41473] = 15, + [42879] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1219), 1, - anon_sym_COLON, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1214), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41525] = 15, + [42937] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(780), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(746), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41577] = 15, + [42995] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(748), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1221), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41629] = 15, + [43053] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(770), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(818), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41681] = 15, + [43111] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1034), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1216), 1, + anon_sym_COLON, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41733] = 15, + [43169] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(1218), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(552), 4, + anon_sym_LT, + anon_sym_GT, anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, + anon_sym_LT2, + ACTIONS(554), 16, sym__call_open_gap, - ACTIONS(449), 1, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(455), 1, + anon_sym_STAR, anon_sym_QMARK, - ACTIONS(457), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, anon_sym_AMP_AMP, - ACTIONS(1223), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(461), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41785] = 15, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [43201] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(725), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(792), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41837] = 15, + [43259] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(752), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1225), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41889] = 15, + [43317] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(738), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1227), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41941] = 15, + [43375] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1220), 1, + anon_sym_RBRACE, + STATE(1332), 1, + sym_qualified_path, + STATE(1507), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(538), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [43427] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(754), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1229), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41993] = 15, + [43485] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(782), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1231), 1, - anon_sym_COLON, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42045] = 15, + [43543] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(756), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1233), 1, - anon_sym_RBRACK, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42097] = 15, + [43601] = 17, ACTIONS(298), 1, sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, ACTIONS(758), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42149] = 15, + [43659] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1235), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1222), 1, + anon_sym_RBRACK, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42201] = 15, + [43717] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(760), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1237), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42253] = 15, + [43775] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(762), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1239), 1, - anon_sym_COLON, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42305] = 15, + [43833] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1241), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1224), 1, + anon_sym_COMMA, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42357] = 15, + [43891] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(730), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1226), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42409] = 15, + [43949] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(1228), 1, + anon_sym_opaque, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(828), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(749), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [44003] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(732), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1230), 1, + anon_sym_COMMA, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42461] = 15, + [44061] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1243), 1, - sym__statement_break, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1232), 1, + anon_sym_RBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42513] = 15, + [44119] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(719), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(764), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42565] = 15, + [44177] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(723), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(766), 1, sym__statement_break, - ACTIONS(997), 1, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(1008), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42617] = 15, + [44235] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(768), 1, + sym__statement_break, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1245), 1, - anon_sym_COMMA, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42669] = 15, + [44293] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(988), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(998), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1247), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + ACTIONS(1008), 1, + anon_sym_SLASH, + ACTIONS(1010), 1, + anon_sym_PIPE_GT, + ACTIONS(1012), 1, + anon_sym_LBRACK2, + ACTIONS(1014), 1, + sym__call_open_gap, + ACTIONS(1234), 1, + sym__statement_break, + STATE(1362), 1, + sym__call_type_arguments, + ACTIONS(992), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(996), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1006), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42721] = 15, + [44351] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1238), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1236), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44380] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(764), 1, - sym__statement_break, - ACTIONS(997), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(999), 1, - anon_sym_PIPE_GT, - ACTIONS(1001), 1, - anon_sym_LBRACK2, - ACTIONS(1003), 1, - sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_LBRACE, - ACTIONS(1011), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1013), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1015), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1021), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1007), 2, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1240), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1009), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1019), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1017), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42773] = 15, + [44435] = 13, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + STATE(1332), 1, + sym_qualified_path, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(582), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [44484] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(455), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(457), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(459), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1249), 1, - anon_sym_COMMA, - ACTIONS(433), 2, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42825] = 15, + [44539] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(1242), 1, anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1251), 1, - anon_sym_RBRACE, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42877] = 15, + [44594] = 13, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LBRACE, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + STATE(1332), 1, + sym_qualified_path, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + STATE(543), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [44643] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1246), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1244), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44672] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(1248), 1, anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1253), 1, - anon_sym_RPAREN, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42929] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(417), 4, - anon_sym_COLON, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(419), 15, - anon_sym_DOT, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - anon_sym_PLUS, - [42956] = 12, + [44727] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(981), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - ACTIONS(985), 1, + ACTIONS(1060), 1, anon_sym_LBRACK, - ACTIONS(991), 1, + ACTIONS(1066), 1, sym_float, - ACTIONS(1028), 1, + ACTIONS(1152), 1, sym_identifier, - STATE(1135), 1, - sym_pattern, - STATE(1267), 1, + STATE(1332), 1, sym_qualified_path, - ACTIONS(987), 2, + STATE(1599), 1, + sym_pattern, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, + ACTIONS(1064), 2, anon_sym_true, anon_sym_false, - ACTIONS(983), 4, + STATE(572), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1058), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1091), 4, + STATE(1112), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [43001] = 6, + [44776] = 16, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1250), 1, + anon_sym_LBRACE, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [44831] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(963), 1, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + ACTIONS(984), 1, anon_sym_LT, - ACTIONS(965), 1, + ACTIONS(986), 1, anon_sym_LBRACK, - ACTIONS(1134), 1, + ACTIONS(1252), 1, anon_sym_LBRACE, - ACTIONS(1138), 1, + ACTIONS(1256), 1, anon_sym_LPAREN, - ACTIONS(1136), 15, + STATE(397), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1254), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42142,683 +43537,734 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [43034] = 6, + [44870] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(823), 1, - anon_sym_COLON_COLON, - ACTIONS(1134), 1, - anon_sym_LBRACE, - ACTIONS(1138), 1, - anon_sym_LPAREN, - STATE(390), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1136), 15, + ACTIONS(1260), 3, anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1258), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_where, sym_static_stage, anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, - sym__doc_comment_line, - [43067] = 12, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - ACTIONS(981), 1, - anon_sym_LPAREN, - ACTIONS(985), 1, - anon_sym_LBRACK, - ACTIONS(991), 1, - sym_float, - ACTIONS(1028), 1, sym_identifier, - STATE(1255), 1, - sym_pattern, - STATE(1267), 1, - sym_qualified_path, - ACTIONS(987), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(989), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(983), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1091), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [43112] = 14, + [44899] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1264), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1262), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44928] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1255), 1, + ACTIONS(1266), 1, anon_sym_LBRACE, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43161] = 14, + [44983] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1270), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1268), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [45012] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(435), 1, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(437), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(439), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(441), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(449), 1, + ACTIONS(1272), 1, anon_sym_LBRACE, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(433), 2, + STATE(1564), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(453), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43210] = 14, + [45067] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1257), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1274), 1, + anon_sym_DOT_DOT_DOT, + STATE(1274), 1, + sym_pattern, + STATE(1332), 1, + sym_qualified_path, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43259] = 14, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45115] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1259), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1276), 1, + anon_sym_DOT_DOT_DOT, + STATE(1274), 1, + sym_pattern, + STATE(1332), 1, + sym_qualified_path, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43308] = 14, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45163] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1261), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + ACTIONS(1278), 1, + anon_sym_RBRACK, + STATE(1175), 1, + sym_pattern, + STATE(1332), 1, + sym_qualified_path, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43357] = 12, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45211] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(981), 1, + ACTIONS(1056), 1, anon_sym_LPAREN, - ACTIONS(985), 1, + ACTIONS(1060), 1, anon_sym_LBRACK, - ACTIONS(991), 1, + ACTIONS(1066), 1, sym_float, - ACTIONS(1028), 1, + ACTIONS(1152), 1, sym_identifier, - STATE(1259), 1, + STATE(1331), 1, sym_pattern, - STATE(1267), 1, + STATE(1332), 1, sym_qualified_path, - ACTIONS(987), 2, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(989), 2, + ACTIONS(1064), 2, anon_sym_true, anon_sym_false, - ACTIONS(983), 4, + ACTIONS(1058), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1091), 4, + STATE(1112), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [43402] = 14, + [45256] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1263), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + STATE(1274), 1, + sym_pattern, + STATE(1332), 1, + sym_qualified_path, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43451] = 14, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45301] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(429), 1, - anon_sym_DOT, - ACTIONS(435), 1, - anon_sym_SLASH, - ACTIONS(437), 1, - anon_sym_PIPE_GT, - ACTIONS(439), 1, - anon_sym_LBRACK2, - ACTIONS(441), 1, - sym__call_open_gap, - ACTIONS(455), 1, - anon_sym_QMARK, - ACTIONS(457), 1, - anon_sym_PIPE_PIPE, - ACTIONS(459), 1, - anon_sym_AMP_AMP, - ACTIONS(1265), 1, + ACTIONS(1052), 1, anon_sym_LBRACE, - ACTIONS(433), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(453), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 2, + ACTIONS(1056), 1, + anon_sym_LPAREN, + ACTIONS(1060), 1, + anon_sym_LBRACK, + ACTIONS(1066), 1, + sym_float, + ACTIONS(1152), 1, + sym_identifier, + STATE(1183), 1, + sym_pattern, + STATE(1332), 1, + sym_qualified_path, + ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(461), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43500] = 5, - ACTIONS(298), 1, + ACTIONS(1064), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1058), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1112), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45346] = 6, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(839), 1, anon_sym_COLON_COLON, - STATE(561), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(413), 3, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(415), 13, - anon_sym_DOT, + ACTIONS(1252), 1, anon_sym_LBRACE, + ACTIONS(1256), 1, + anon_sym_LPAREN, + STATE(397), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1254), 15, anon_sym_RBRACE, - anon_sym_COMMA, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [45379] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(984), 1, anon_sym_LT, - anon_sym_GT, + ACTIONS(986), 1, + anon_sym_LBRACK, + ACTIONS(1252), 1, + anon_sym_LBRACE, + ACTIONS(1256), 1, anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(1254), 15, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [43530] = 14, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [45412] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1269), 1, + ACTIONS(1280), 1, anon_sym_RBRACE, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(636), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43578] = 14, + [45460] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(835), 1, - sym_static_stage, - ACTIONS(837), 1, - anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1292), 1, + anon_sym_RBRACE, + ACTIONS(1294), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1297), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1300), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1303), 1, + sym_static_stage, + ACTIONS(1306), 1, + anon_sym_effect, + ACTIONS(1309), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1312), 1, anon_sym_opaque, - ACTIONS(1281), 1, - anon_sym_RBRACE, - STATE(224), 1, + ACTIONS(1315), 1, + sym__doc_comment_line, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(633), 2, + STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43626] = 14, + [45508] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1283), 1, + ACTIONS(1318), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(635), 2, + STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43674] = 14, + [45556] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1285), 1, + ACTIONS(1320), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, STATE(637), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43722] = 14, + [45604] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1287), 1, + ACTIONS(1322), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(637), 2, + STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43770] = 14, + [45652] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1289), 1, + ACTIONS(1324), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(632), 2, + STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43818] = 14, + [45700] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1291), 1, + ACTIONS(1326), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(637), 2, + STATE(639), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43866] = 14, + [45748] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(835), 1, + ACTIONS(861), 1, sym_static_stage, - ACTIONS(837), 1, + ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1271), 1, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1273), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1275), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1277), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1279), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1293), 1, + ACTIONS(1328), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(637), 2, + STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43914] = 14, + [45796] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1295), 1, - anon_sym_RBRACE, - ACTIONS(1297), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1300), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1303), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1306), 1, - sym_static_stage, - ACTIONS(1309), 1, - anon_sym_effect, - ACTIONS(1312), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1315), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1318), 1, - sym__doc_comment_line, - STATE(224), 1, + ACTIONS(1330), 1, + anon_sym_RBRACE, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(1289), 1, + STATE(1345), 1, sym_doc_comment, - STATE(637), 2, + STATE(640), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(859), 5, + STATE(930), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [43962] = 4, + [45844] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1134), 1, + ACTIONS(1252), 1, anon_sym_LBRACE, - ACTIONS(1138), 1, + ACTIONS(1256), 1, anon_sym_LPAREN, - ACTIONS(1136), 15, + ACTIONS(1254), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42834,14 +44280,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [43989] = 4, + [45871] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1323), 1, + ACTIONS(1334), 1, anon_sym_PIPE, - STATE(639), 1, + STATE(645), 1, aux_sym_union_type_repeat1, - ACTIONS(1321), 14, + ACTIONS(1332), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42856,14 +44302,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44015] = 4, + [45897] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1328), 1, + ACTIONS(1339), 1, anon_sym_PIPE, - STATE(639), 1, + STATE(647), 1, aux_sym_union_type_repeat1, - ACTIONS(1326), 14, + ACTIONS(1337), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42878,14 +44324,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44041] = 4, + [45923] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1328), 1, + ACTIONS(1339), 1, anon_sym_PIPE, - STATE(640), 1, + STATE(645), 1, aux_sym_union_type_repeat1, - ACTIONS(1330), 14, + ACTIONS(1341), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42900,10 +44346,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44067] = 2, + [45949] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1332), 15, + ACTIONS(1343), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42919,31 +44365,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44088] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1336), 1, - anon_sym_where, - STATE(703), 1, - sym_type_validation, - ACTIONS(1334), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [44113] = 2, + [45970] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1338), 15, + ACTIONS(1332), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -42959,39 +44384,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44134] = 4, + [45991] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1336), 1, + ACTIONS(1347), 1, anon_sym_where, - STATE(689), 1, + STATE(732), 1, sym_type_validation, - ACTIONS(1340), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [44159] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1321), 15, + ACTIONS(1345), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -42999,14 +44405,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44180] = 4, + [46016] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1336), 1, + ACTIONS(1347), 1, anon_sym_where, - STATE(722), 1, + STATE(697), 1, sym_type_validation, - ACTIONS(1342), 13, + ACTIONS(1349), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43020,14 +44426,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44205] = 4, + [46041] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1336), 1, + ACTIONS(1347), 1, anon_sym_where, - STATE(741), 1, + STATE(716), 1, sym_type_validation, - ACTIONS(1344), 13, + ACTIONS(1351), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43041,59 +44447,83 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44230] = 7, + [46066] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(959), 1, + ACTIONS(423), 1, anon_sym_EQ, - ACTIONS(1267), 1, + ACTIONS(1353), 1, anon_sym_COLON_COLON, - ACTIONS(1346), 1, + STATE(653), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(425), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_LT, - ACTIONS(1348), 1, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, anon_sym_LBRACK, - STATE(628), 1, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46093] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(419), 1, + anon_sym_EQ, + ACTIONS(1356), 1, + anon_sym_COLON_COLON, + STATE(653), 1, aux_sym_qualified_path_repeat1, - ACTIONS(961), 10, + ACTIONS(421), 12, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, + anon_sym_LT, anon_sym_GT, anon_sym_RPAREN, anon_sym_PIPE, anon_sym_where, anon_sym_BANG, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_EQ_GT, - [44261] = 2, + [46120] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1350), 14, + ACTIONS(1358), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44281] = 2, + [46141] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1352), 14, + ACTIONS(1347), 1, + anon_sym_where, + STATE(708), 1, + sym_type_validation, + ACTIONS(1360), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -43101,35 +44531,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44301] = 9, + [46166] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1354), 1, - sym_identifier, + ACTIONS(980), 1, + anon_sym_EQ, ACTIONS(1356), 1, + anon_sym_COLON_COLON, + ACTIONS(1362), 1, + anon_sym_LT, + ACTIONS(1364), 1, + anon_sym_LBRACK, + STATE(654), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(982), 10, anon_sym_LBRACE, - ACTIONS(1358), 1, - anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - STATE(617), 1, - sym_qualified_path, - STATE(641), 1, - sym_variant, - STATE(643), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(651), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [44335] = 2, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46197] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1362), 14, + ACTIONS(1366), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43144,117 +44573,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44355] = 9, + [46217] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1354), 1, + ACTIONS(1368), 1, sym_identifier, - ACTIONS(1356), 1, + ACTIONS(1370), 1, anon_sym_LBRACE, - ACTIONS(1358), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - STATE(617), 1, + STATE(954), 1, sym_qualified_path, - STATE(641), 1, + STATE(1109), 1, sym_variant, - STATE(648), 3, + STATE(1251), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(651), 5, + STATE(1312), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [44389] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1364), 14, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym__doc_comment_line, - [44409] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1368), 1, - anon_sym_DASH_GT, - ACTIONS(1366), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [44431] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1372), 1, - anon_sym_DASH_GT, - ACTIONS(1370), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [44453] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1374), 14, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym__doc_comment_line, - [44473] = 3, + [46251] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1378), 1, - anon_sym_DASH_GT, - ACTIONS(1376), 13, + ACTIONS(1376), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -43262,10 +44616,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44495] = 2, + [46271] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1380), 14, + ACTIONS(1378), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43280,80 +44634,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44515] = 9, + [46291] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1382), 1, + ACTIONS(1380), 1, sym_identifier, - ACTIONS(1384), 1, - anon_sym_LBRACE, - ACTIONS(1386), 1, - anon_sym_fn, - ACTIONS(1388), 1, - anon_sym_LPAREN, - STATE(935), 1, - sym_qualified_path, - STATE(1101), 1, - sym_variant, - STATE(1124), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(1312), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [44549] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1390), 14, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym__doc_comment_line, - [44569] = 9, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(1382), 1, - sym_identifier, - ACTIONS(1384), 1, anon_sym_LBRACE, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(935), 1, + STATE(634), 1, sym_qualified_path, - STATE(1101), 1, + STATE(646), 1, sym_variant, - STATE(1241), 3, + STATE(651), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1312), 5, + STATE(660), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [44603] = 3, + [46325] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(1390), 1, anon_sym_DASH_GT, - ACTIONS(1392), 13, + ACTIONS(1388), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43367,10 +44678,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44625] = 2, + [46347] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1396), 14, + ACTIONS(1392), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43385,60 +44696,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44645] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1354), 1, - sym_identifier, - ACTIONS(1356), 1, - anon_sym_LBRACE, - ACTIONS(1358), 1, - anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - STATE(617), 1, - sym_qualified_path, - STATE(641), 1, - sym_variant, - STATE(645), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(651), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [44679] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1354), 1, - sym_identifier, - ACTIONS(1356), 1, - anon_sym_LBRACE, - ACTIONS(1358), 1, - anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - STATE(617), 1, - sym_qualified_path, - STATE(641), 1, - sym_variant, - STATE(647), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(651), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [44713] = 2, + [46367] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1398), 14, + ACTIONS(1394), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43453,28 +44714,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44733] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1400), 14, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [44753] = 2, + [46387] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1402), 14, + ACTIONS(1396), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43489,10 +44732,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44773] = 2, + [46407] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1404), 14, + ACTIONS(1400), 1, + anon_sym_DASH_GT, + ACTIONS(1398), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43504,56 +44749,55 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44793] = 2, + [46429] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1406), 14, + ACTIONS(1402), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44813] = 9, + [46449] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1382), 1, + ACTIONS(1380), 1, sym_identifier, - ACTIONS(1384), 1, + ACTIONS(1382), 1, anon_sym_LBRACE, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(935), 1, + STATE(634), 1, sym_qualified_path, - STATE(1101), 1, + STATE(646), 1, sym_variant, - STATE(1151), 3, + STATE(652), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1312), 5, + STATE(660), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [44847] = 2, + [46483] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1408), 14, + ACTIONS(1404), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43568,10 +44812,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44867] = 2, + [46503] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1410), 14, + ACTIONS(1408), 1, + anon_sym_DASH_GT, + ACTIONS(1406), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43583,13 +44829,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44887] = 2, + [46525] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1412), 14, + ACTIONS(1410), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43604,10 +44849,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44907] = 2, + [46545] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 14, + ACTIONS(1412), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43622,10 +44867,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44927] = 2, + [46565] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1416), 14, + ACTIONS(1416), 1, + anon_sym_DASH_GT, + ACTIONS(1414), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43637,38 +44884,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [44947] = 9, + [46587] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1382), 1, + ACTIONS(1380), 1, sym_identifier, - ACTIONS(1384), 1, + ACTIONS(1382), 1, anon_sym_LBRACE, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(935), 1, + STATE(634), 1, sym_qualified_path, - STATE(1101), 1, + STATE(646), 1, sym_variant, - STATE(1153), 3, + STATE(650), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1312), 5, + STATE(660), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [44981] = 2, + [46621] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1418), 13, + ACTIONS(1418), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43680,12 +44926,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45000] = 2, + [46641] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1420), 13, + ACTIONS(1420), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43697,12 +44944,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45019] = 2, + [46661] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1422), 13, + ACTIONS(1422), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43714,12 +44962,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45038] = 2, + [46681] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1424), 13, + ACTIONS(1424), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43731,12 +44980,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45057] = 2, + [46701] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1426), 13, + ACTIONS(1426), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43748,12 +44998,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45076] = 2, + [46721] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1368), 1, + sym_identifier, + ACTIONS(1370), 1, + anon_sym_LBRACE, + ACTIONS(1372), 1, + anon_sym_fn, + ACTIONS(1374), 1, + anon_sym_LPAREN, + STATE(954), 1, + sym_qualified_path, + STATE(1109), 1, + sym_variant, + STATE(1222), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(1312), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46755] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1428), 13, + ACTIONS(1428), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43765,12 +45041,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45095] = 2, + [46775] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1430), 13, + ACTIONS(1430), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43782,12 +45059,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45114] = 2, + [46795] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1432), 13, + ACTIONS(1432), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43799,9 +45077,104 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [45133] = 2, + [46815] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(423), 1, + anon_sym_EQ, + ACTIONS(425), 13, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46837] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1368), 1, + sym_identifier, + ACTIONS(1370), 1, + anon_sym_LBRACE, + ACTIONS(1372), 1, + anon_sym_fn, + ACTIONS(1374), 1, + anon_sym_LPAREN, + STATE(954), 1, + sym_qualified_path, + STATE(1109), 1, + sym_variant, + STATE(1134), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(1312), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46871] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1380), 1, + sym_identifier, + ACTIONS(1382), 1, + anon_sym_LBRACE, + ACTIONS(1384), 1, + anon_sym_fn, + ACTIONS(1386), 1, + anon_sym_LPAREN, + STATE(634), 1, + sym_qualified_path, + STATE(646), 1, + sym_variant, + STATE(656), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(660), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46905] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1368), 1, + sym_identifier, + ACTIONS(1370), 1, + anon_sym_LBRACE, + ACTIONS(1372), 1, + anon_sym_fn, + ACTIONS(1374), 1, + anon_sym_LPAREN, + STATE(954), 1, + sym_qualified_path, + STATE(1109), 1, + sym_variant, + STATE(1210), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(1312), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46939] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1434), 13, @@ -43818,7 +45191,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45152] = 2, + [46958] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1436), 13, @@ -43835,7 +45208,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45171] = 2, + [46977] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(980), 1, + anon_sym_EQ, + ACTIONS(1362), 1, + anon_sym_LT, + ACTIONS(1364), 1, + anon_sym_LBRACK, + ACTIONS(982), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [47002] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1438), 13, @@ -43852,7 +45245,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45190] = 2, + [47021] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1440), 13, @@ -43869,7 +45262,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45209] = 2, + [47040] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1442), 13, @@ -43886,7 +45279,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45228] = 2, + [47059] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1444), 13, @@ -43903,7 +45296,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45247] = 2, + [47078] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1446), 13, @@ -43920,7 +45313,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45266] = 2, + [47097] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1448), 13, @@ -43937,27 +45330,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45285] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(959), 1, - anon_sym_EQ, - ACTIONS(1346), 1, - anon_sym_LT, - ACTIONS(1348), 1, - anon_sym_LBRACK, - ACTIONS(961), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [45310] = 2, + [47116] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1450), 13, @@ -43974,7 +45347,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45329] = 2, + [47135] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1452), 13, @@ -43991,7 +45364,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45348] = 2, + [47154] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1454), 13, @@ -44008,7 +45381,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45367] = 2, + [47173] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1456), 13, @@ -44025,7 +45398,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45386] = 2, + [47192] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1458), 13, @@ -44042,7 +45415,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45405] = 2, + [47211] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1460), 13, @@ -44059,7 +45432,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45424] = 2, + [47230] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1462), 13, @@ -44076,7 +45449,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45443] = 2, + [47249] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1464), 13, @@ -44093,7 +45466,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45462] = 2, + [47268] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1466), 13, @@ -44110,7 +45483,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45481] = 2, + [47287] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1468), 13, @@ -44127,7 +45500,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45500] = 2, + [47306] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1470), 13, @@ -44144,7 +45517,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45519] = 2, + [47325] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1472), 13, @@ -44161,7 +45534,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45538] = 2, + [47344] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1474), 13, @@ -44178,7 +45551,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45557] = 2, + [47363] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1476), 13, @@ -44195,7 +45568,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45576] = 2, + [47382] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1478), 13, @@ -44212,7 +45585,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45595] = 2, + [47401] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1480), 13, @@ -44229,7 +45602,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45614] = 2, + [47420] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1482), 13, @@ -44246,7 +45619,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45633] = 2, + [47439] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1484), 13, @@ -44263,7 +45636,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45652] = 2, + [47458] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1486), 13, @@ -44280,7 +45653,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45671] = 2, + [47477] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1488), 13, @@ -44297,7 +45670,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45690] = 2, + [47496] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1490), 13, @@ -44314,7 +45687,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45709] = 2, + [47515] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1492), 13, @@ -44331,7 +45704,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45728] = 2, + [47534] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1494), 13, @@ -44348,7 +45721,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45747] = 2, + [47553] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1496), 13, @@ -44365,7 +45738,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45766] = 2, + [47572] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1498), 13, @@ -44382,7 +45755,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45785] = 2, + [47591] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1500), 13, @@ -44399,7 +45772,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45804] = 2, + [47610] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1502), 13, @@ -44416,7 +45789,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45823] = 2, + [47629] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1504), 13, @@ -44433,7 +45806,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45842] = 2, + [47648] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1506), 13, @@ -44450,7 +45823,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45861] = 2, + [47667] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1508), 13, @@ -44467,10 +45840,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45880] = 2, + [47686] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(498), 13, + ACTIONS(1510), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44484,10 +45857,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45899] = 2, + [47705] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(685), 13, + ACTIONS(1512), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44501,10 +45874,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45918] = 2, + [47724] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1510), 13, + ACTIONS(1514), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44518,10 +45891,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45937] = 2, + [47743] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1512), 13, + ACTIONS(1516), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44535,10 +45908,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45956] = 2, + [47762] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1514), 13, + ACTIONS(1518), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44552,10 +45925,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45975] = 2, + [47781] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1516), 13, + ACTIONS(1520), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44569,28 +45942,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45994] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(823), 1, - anon_sym_COLON_COLON, - ACTIONS(1520), 1, - anon_sym_LT, - STATE(390), 1, - aux_sym_qualified_path_repeat1, - STATE(887), 1, - sym_type_arguments, - ACTIONS(1518), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [46021] = 2, + [47800] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1522), 13, @@ -44607,7 +45959,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46040] = 2, + [47819] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1524), 13, @@ -44624,7 +45976,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46059] = 2, + [47838] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1526), 13, @@ -44641,7 +45993,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46078] = 2, + [47857] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1528), 13, @@ -44658,7 +46010,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46097] = 2, + [47876] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1530), 13, @@ -44675,7 +46027,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46116] = 2, + [47895] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1532), 13, @@ -44692,7 +46044,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46135] = 2, + [47914] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1534), 13, @@ -44709,7 +46061,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46154] = 2, + [47933] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1536), 13, @@ -44726,7 +46078,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46173] = 2, + [47952] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1538), 13, @@ -44743,7 +46095,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46192] = 2, + [47971] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1540), 13, @@ -44760,7 +46112,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46211] = 2, + [47990] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1542), 13, @@ -44777,7 +46129,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46230] = 2, + [48009] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1544), 13, @@ -44794,7 +46146,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46249] = 2, + [48028] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1546), 13, @@ -44811,7 +46163,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46268] = 2, + [48047] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1548), 13, @@ -44828,7 +46180,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46287] = 2, + [48066] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1550), 13, @@ -44845,7 +46197,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46306] = 2, + [48085] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1552), 13, @@ -44862,7 +46214,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46325] = 2, + [48104] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1554), 13, @@ -44879,40 +46231,288 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46344] = 10, + [48123] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1556), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48142] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1558), 1, + anon_sym_COLON_COLON, + ACTIONS(1562), 1, + anon_sym_LT2, + STATE(773), 1, + aux_sym_qualified_path_repeat1, + STATE(880), 1, + sym_type_arguments, + ACTIONS(1560), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48169] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(568), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48188] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(600), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48207] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1564), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48226] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1566), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48245] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1568), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48264] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1570), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48283] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1572), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48302] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1558), 1, + ACTIONS(1576), 1, anon_sym_RBRACE, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(770), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46378] = 5, + [48336] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(423), 1, + anon_sym_COLON, + ACTIONS(1582), 1, + anon_sym_COLON_COLON, + STATE(761), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(425), 9, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_LPAREN, + anon_sym_RBRACK, + anon_sym_PLUS, + anon_sym_LT2, + sym_identifier, + [48360] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1566), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(1574), 1, + sym_identifier, + ACTIONS(1580), 1, + sym_replayable, + ACTIONS(1585), 1, + anon_sym_RBRACE, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(952), 1, + sym_multiplicity, + STATE(972), 1, + sym_doc_comment, + STATE(777), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [48394] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(1574), 1, + sym_identifier, + ACTIONS(1580), 1, + sym_replayable, + ACTIONS(1587), 1, + anon_sym_RBRACE, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(952), 1, + sym_multiplicity, + STATE(972), 1, + sym_doc_comment, + STATE(768), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [48428] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(1574), 1, + sym_identifier, + ACTIONS(1580), 1, + sym_replayable, + ACTIONS(1589), 1, + anon_sym_RBRACE, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(952), 1, + sym_multiplicity, + STATE(972), 1, + sym_doc_comment, + STATE(768), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [48462] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1593), 1, anon_sym_DASH_GT, - ACTIONS(1568), 1, + ACTIONS(1595), 1, anon_sym_BANG, - STATE(889), 1, + STATE(879), 1, sym_effect_set, - ACTIONS(1564), 9, + ACTIONS(1591), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -44922,466 +46522,544 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [46402] = 10, + [48486] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1570), 1, + ACTIONS(1597), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(774), 2, + STATE(775), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46436] = 10, + [48520] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + STATE(779), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1599), 10, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48542] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1601), 1, + sym_identifier, + ACTIONS(1604), 1, + anon_sym_RBRACE, + ACTIONS(1609), 1, + sym_replayable, + ACTIONS(1612), 1, + sym__doc_comment_line, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(952), 1, + sym_multiplicity, + STATE(972), 1, + sym_doc_comment, + STATE(768), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1606), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [48576] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1572), 1, + ACTIONS(1615), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(757), 2, + STATE(763), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46470] = 10, + [48610] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1574), 1, + ACTIONS(1617), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(767), 2, + STATE(764), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46504] = 10, + [48644] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1576), 1, + ACTIONS(1619), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(761), 2, + STATE(787), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46538] = 10, + [48678] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1578), 1, + ACTIONS(1621), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46572] = 4, + [48712] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(823), 1, + ACTIONS(1558), 1, anon_sym_COLON_COLON, - STATE(787), 1, + STATE(774), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1580), 10, + ACTIONS(421), 10, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_PLUS, + anon_sym_LT2, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48734] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1623), 1, + anon_sym_COLON_COLON, + STATE(774), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(425), 10, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_LT2, anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [46594] = 10, + [48756] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1582), 1, + ACTIONS(1626), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(779), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46628] = 10, + [48790] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1584), 1, + ACTIONS(1628), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(764), 2, + STATE(760), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46662] = 10, + [48824] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1586), 1, + ACTIONS(1630), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46696] = 10, + [48858] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1588), 1, + ACTIONS(1632), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(780), 2, + STATE(782), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46730] = 10, + [48892] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + STATE(396), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1634), 10, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48914] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1590), 1, + ACTIONS(1636), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46764] = 10, + [48948] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1592), 1, + ACTIONS(1638), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(784), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46798] = 10, + [48982] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1594), 1, + ACTIONS(1640), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(784), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46832] = 10, + [49016] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1596), 1, + ACTIONS(1642), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(778), 2, + STATE(788), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46866] = 10, + [49050] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1598), 1, + ACTIONS(1644), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46900] = 10, + [49084] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1600), 1, + ACTIONS(1646), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(791), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46934] = 10, + [49118] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1602), 1, + ACTIONS(1648), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(773), 2, + STATE(797), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [46968] = 10, + [49152] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1604), 1, + ACTIONS(1650), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47002] = 10, + [49186] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1606), 1, + ACTIONS(1652), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(776), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47036] = 5, + [49220] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1595), 1, anon_sym_BANG, - ACTIONS(1610), 1, + ACTIONS(1656), 1, anon_sym_DASH_GT, - STATE(908), 1, + STATE(882), 1, sym_effect_set, - ACTIONS(1608), 9, + ACTIONS(1654), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45391,365 +47069,292 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47060] = 10, + [49244] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1612), 1, + ACTIONS(1658), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(793), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47094] = 10, + [49278] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1614), 1, + ACTIONS(1660), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47128] = 10, + [49312] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1616), 1, + ACTIONS(1662), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(777), 2, + STATE(795), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47162] = 10, + [49346] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1618), 1, + ACTIONS(1664), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47196] = 10, + [49380] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1620), 1, + ACTIONS(1666), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47230] = 10, + [49414] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1622), 1, + ACTIONS(1668), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47264] = 10, + [49448] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1624), 1, + ACTIONS(1670), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47298] = 10, + [49482] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1626), 1, + ACTIONS(1672), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(768), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47332] = 5, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1568), 1, - anon_sym_BANG, - ACTIONS(1630), 1, - anon_sym_DASH_GT, - STATE(856), 1, - sym_effect_set, - ACTIONS(1628), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [47356] = 10, + [49516] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1632), 1, + ACTIONS(1674), 1, anon_sym_RBRACE, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(789), 2, + STATE(772), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47390] = 10, + [49550] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(1556), 1, - sym_identifier, - ACTIONS(1562), 1, - sym_replayable, - ACTIONS(1634), 1, + ACTIONS(1595), 1, + anon_sym_BANG, + ACTIONS(1678), 1, + anon_sym_DASH_GT, + STATE(932), 1, + sym_effect_set, + ACTIONS(1676), 9, anon_sym_RBRACE, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(934), 1, - sym_multiplicity, - STATE(963), 1, - sym_doc_comment, - STATE(785), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [47424] = 10, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, sym__doc_comment_line, - ACTIONS(1556), 1, - sym_identifier, - ACTIONS(1562), 1, - sym_replayable, - ACTIONS(1636), 1, - anon_sym_RBRACE, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(934), 1, - sym_multiplicity, - STATE(963), 1, - sym_doc_comment, - STATE(786), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [47458] = 10, + [49574] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1556), 1, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1562), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1638), 1, - anon_sym_RBRACE, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(934), 1, - sym_multiplicity, - STATE(963), 1, - sym_doc_comment, - STATE(786), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [47492] = 10, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1640), 1, - sym_identifier, - ACTIONS(1643), 1, + ACTIONS(1680), 1, anon_sym_RBRACE, - ACTIONS(1648), 1, - sym_replayable, - ACTIONS(1651), 1, - sym__doc_comment_line, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(934), 1, + STATE(952), 1, sym_multiplicity, - STATE(963), 1, + STATE(972), 1, sym_doc_comment, - STATE(786), 2, + STATE(780), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1645), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [47526] = 4, + [49608] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(823), 1, - anon_sym_COLON_COLON, - STATE(389), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1654), 10, + ACTIONS(1595), 1, + anon_sym_BANG, + ACTIONS(1684), 1, + anon_sym_DASH_GT, + STATE(898), 1, + sym_effect_set, + ACTIONS(1682), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_PLUS, anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47548] = 5, + [49632] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1595), 1, anon_sym_BANG, - ACTIONS(1658), 1, - anon_sym_DASH_GT, - STATE(920), 1, + STATE(934), 1, sym_effect_set, - ACTIONS(1656), 9, + ACTIONS(1686), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45759,36 +47364,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47572] = 10, - ACTIONS(3), 1, + [49653] = 3, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(1556), 1, - sym_identifier, - ACTIONS(1562), 1, - sym_replayable, - ACTIONS(1660), 1, + ACTIONS(1244), 1, + anon_sym_EQ, + ACTIONS(1246), 10, + anon_sym_LBRACE, anon_sym_RBRACE, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(934), 1, - sym_multiplicity, - STATE(963), 1, - sym_doc_comment, - STATE(786), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [47606] = 3, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [49672] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1160), 1, + ACTIONS(1268), 1, anon_sym_EQ, - ACTIONS(1162), 10, + ACTIONS(1270), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -45799,14 +47396,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [47625] = 4, + [49691] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1664), 1, + ACTIONS(1690), 1, anon_sym_EQ, - ACTIONS(1666), 1, + ACTIONS(1692), 1, anon_sym_LT, - ACTIONS(1662), 9, + ACTIONS(1688), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45816,14 +47413,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47646] = 4, + [49712] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1568), 1, - anon_sym_BANG, - STATE(876), 1, - sym_effect_set, - ACTIONS(1668), 9, + ACTIONS(1696), 1, + anon_sym_EQ, + ACTIONS(1698), 1, + anon_sym_LT, + ACTIONS(1694), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45833,12 +47430,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47667] = 3, + [49733] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1156), 1, + ACTIONS(1258), 1, anon_sym_EQ, - ACTIONS(1158), 10, + ACTIONS(1260), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -45849,71 +47446,77 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [47686] = 4, - ACTIONS(3), 1, + [49752] = 3, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1262), 1, + anon_sym_EQ, + ACTIONS(1264), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, anon_sym_BANG, - STATE(832), 1, - sym_effect_set, - ACTIONS(1670), 9, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [49771] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1236), 1, + anon_sym_EQ, + ACTIONS(1238), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [49790] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(425), 11, + anon_sym_COLON_COLON, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_LT2, anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47707] = 11, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1674), 1, - anon_sym_fn, - ACTIONS(1676), 1, - anon_sym_extern, - ACTIONS(1678), 1, - anon_sym_type, - ACTIONS(1680), 1, - sym_static_stage, - ACTIONS(1682), 1, - anon_sym_effect, - ACTIONS(1684), 1, - anon_sym_state, - ACTIONS(1686), 1, - anon_sym_module, - ACTIONS(1688), 1, - anon_sym_export, - ACTIONS(1690), 1, - anon_sym_signature, - ACTIONS(1672), 2, - anon_sym_let, - anon_sym_mut, - [47742] = 3, + [49807] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1164), 1, - anon_sym_EQ, - ACTIONS(1166), 10, + ACTIONS(423), 1, + anon_sym_COLON, + ACTIONS(425), 10, + anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, + anon_sym_EQ, + anon_sym_LPAREN, anon_sym_RBRACK, - anon_sym_EQ_GT, - [47761] = 4, + anon_sym_PLUS, + anon_sym_LT2, + sym_identifier, + [49826] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1595), 1, anon_sym_BANG, - STATE(827), 1, + STATE(843), 1, sym_effect_set, - ACTIONS(1692), 9, + ACTIONS(1700), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45923,14 +47526,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47782] = 4, + [49847] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1595), 1, anon_sym_BANG, - STATE(917), 1, + STATE(903), 1, sym_effect_set, - ACTIONS(1694), 9, + ACTIONS(1702), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45940,189 +47543,181 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47803] = 8, + [49868] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1567), 1, + STATE(1377), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47832] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1126), 1, - anon_sym_EQ, - ACTIONS(1128), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [47851] = 8, + [49897] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1704), 1, + ACTIONS(1712), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1583), 1, + STATE(1442), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47880] = 8, + [49926] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1706), 1, + ACTIONS(1714), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1597), 1, + STATE(1592), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47909] = 8, + [49955] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, - anon_sym_LPAREN, ACTIONS(1708), 1, + anon_sym_LPAREN, + ACTIONS(1716), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1631), 1, + STATE(1608), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47938] = 8, + [49984] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1562), 1, + anon_sym_LT2, + STATE(880), 1, + sym_type_arguments, + ACTIONS(1560), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50005] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1710), 1, + ACTIONS(1718), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1554), 1, + STATE(1657), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47967] = 4, - ACTIONS(3), 1, + [50034] = 11, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1714), 1, - anon_sym_EQ, - ACTIONS(1716), 1, - anon_sym_LT, - ACTIONS(1712), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1722), 1, anon_sym_fn, + ACTIONS(1724), 1, + anon_sym_extern, + ACTIONS(1726), 1, anon_sym_type, + ACTIONS(1728), 1, sym_static_stage, + ACTIONS(1730), 1, anon_sym_effect, + ACTIONS(1732), 1, + anon_sym_state, + ACTIONS(1734), 1, anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [47988] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1172), 1, - anon_sym_EQ, - ACTIONS(1174), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [48007] = 8, + ACTIONS(1736), 1, + anon_sym_export, + ACTIONS(1738), 1, + anon_sym_signature, + ACTIONS(1720), 2, + anon_sym_let, + anon_sym_mut, + [50069] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1718), 1, + ACTIONS(1740), 1, anon_sym_RPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1637), 1, + STATE(1663), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48036] = 4, + [50098] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1520), 1, - anon_sym_LT, - STATE(887), 1, - sym_type_arguments, - ACTIONS(1518), 9, + ACTIONS(1595), 1, + anon_sym_BANG, + STATE(894), 1, + sym_effect_set, + ACTIONS(1742), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46132,259 +47727,241 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48057] = 7, + [50119] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1720), 1, - anon_sym_LBRACE, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1096), 5, + STATE(1575), 1, + sym_positional_payload, + STATE(1177), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48083] = 8, + [50145] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1722), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1724), 1, - anon_sym_LBRACE, - ACTIONS(1728), 1, - anon_sym_COLON, - ACTIONS(1730), 1, + ACTIONS(1706), 1, + anon_sym_fn, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(628), 1, + STATE(691), 1, + sym_qualified_path, + STATE(1503), 1, + sym_type_list, + STATE(1105), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [50171] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + STATE(761), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1726), 4, + ACTIONS(421), 8, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_COMMA, - anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_LPAREN, anon_sym_RBRACK, - anon_sym_EQ_GT, - [48111] = 7, + anon_sym_LT2, + sym_identifier, + [50191] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1414), 1, - sym_positional_payload, - STATE(1173), 5, + STATE(1748), 1, + sym_type_list, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48137] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1734), 1, - anon_sym_EQ, - ACTIONS(1732), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48155] = 11, + [50217] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(957), 1, + ACTIONS(931), 1, anon_sym_COMMA, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1722), 1, + ACTIONS(1746), 1, sym_identifier, - ACTIONS(1724), 1, + ACTIONS(1748), 1, anon_sym_LBRACE, - ACTIONS(1726), 1, - anon_sym_EQ_GT, - ACTIONS(1728), 1, + ACTIONS(1750), 1, + anon_sym_RBRACE, + ACTIONS(1752), 1, anon_sym_COLON, - ACTIONS(1730), 1, + ACTIONS(1754), 1, anon_sym_LPAREN, - ACTIONS(1736), 1, - anon_sym_RBRACE, - STATE(628), 1, + ACTIONS(1756), 1, + anon_sym_EQ_GT, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1243), 1, + STATE(1124), 1, aux_sym_field_pattern_repeat1, - [48189] = 3, - ACTIONS(3), 1, + [50251] = 10, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1740), 1, - anon_sym_EQ, - ACTIONS(1738), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1722), 1, anon_sym_fn, + ACTIONS(1724), 1, + anon_sym_extern, + ACTIONS(1726), 1, anon_sym_type, + ACTIONS(1728), 1, sym_static_stage, + ACTIONS(1730), 1, anon_sym_effect, + ACTIONS(1732), 1, + anon_sym_state, + ACTIONS(1734), 1, anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48207] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, - anon_sym_fn, - ACTIONS(1700), 1, - anon_sym_LPAREN, - STATE(696), 1, - sym_qualified_path, - STATE(1713), 1, - sym_type_list, - STATE(1092), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48233] = 7, + ACTIONS(1738), 1, + anon_sym_signature, + ACTIONS(1720), 2, + anon_sym_let, + anon_sym_mut, + [50283] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1746), 1, sym_identifier, - ACTIONS(1698), 1, - anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1748), 1, + anon_sym_LBRACE, + ACTIONS(1752), 1, + anon_sym_COLON, + ACTIONS(1754), 1, anon_sym_LPAREN, - STATE(696), 1, - sym_qualified_path, - STATE(1402), 1, - sym_positional_payload, - STATE(1173), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48259] = 7, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1756), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [50311] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1385), 1, + STATE(1405), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48285] = 7, + [50337] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1501), 1, + STATE(1444), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48311] = 7, + [50363] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1448), 1, - sym_type_list, - STATE(1092), 5, + STATE(1422), 1, + sym_positional_payload, + STATE(1177), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48337] = 10, - ACTIONS(298), 1, + [50389] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1674), 1, + ACTIONS(1760), 1, + anon_sym_PLUS, + ACTIONS(1758), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1676), 1, - anon_sym_extern, - ACTIONS(1678), 1, anon_sym_type, - ACTIONS(1680), 1, sym_static_stage, - ACTIONS(1682), 1, anon_sym_effect, - ACTIONS(1684), 1, - anon_sym_state, - ACTIONS(1686), 1, anon_sym_module, - ACTIONS(1690), 1, - anon_sym_signature, - ACTIONS(1672), 2, - anon_sym_let, - anon_sym_mut, - [48369] = 7, + anon_sym_opaque, + sym__doc_comment_line, + [50407] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1562), 1, + STATE(1426), 1, sym_type_list, - STATE(1092), 5, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48395] = 3, + [50433] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1744), 1, - anon_sym_PLUS, - ACTIONS(1742), 9, + ACTIONS(1764), 1, + anon_sym_EQ, + ACTIONS(1762), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46394,74 +47971,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48413] = 6, + [50451] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, - anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1704), 1, sym_identifier, - STATE(438), 1, - sym_qualified_path, - STATE(797), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48436] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + ACTIONS(1766), 1, + anon_sym_LBRACE, + STATE(691), 1, sym_qualified_path, - STATE(851), 5, + STATE(1099), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48459] = 6, + [50477] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(853), 5, + STATE(1523), 1, + sym_type_list, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48482] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1748), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48497] = 2, + [50503] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1750), 9, + ACTIONS(1770), 1, + anon_sym_EQ, + ACTIONS(1768), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46471,78 +48024,61 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48512] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, - anon_sym_fn, - ACTIONS(1700), 1, - anon_sym_LPAREN, - STATE(696), 1, - sym_qualified_path, - STATE(806), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48535] = 6, + [50521] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(793), 5, + STATE(1406), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48558] = 6, + [50544] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(990), 5, + STATE(1519), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48581] = 6, + [50567] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1155), 5, + STATE(1029), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48604] = 2, + [50590] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1752), 9, + ACTIONS(1772), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46552,44 +48088,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48619] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1358), 1, - anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, - sym_qualified_path, - STATE(531), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48642] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, - anon_sym_fn, - ACTIONS(1700), 1, - anon_sym_LPAREN, - STATE(696), 1, - sym_qualified_path, - STATE(1009), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48665] = 2, + [50605] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1754), 9, + ACTIONS(1774), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46599,261 +48101,250 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48680] = 6, + [50620] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1022), 5, + STATE(1272), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48703] = 6, + [50643] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1776), 1, + anon_sym_COLON_COLON, + ACTIONS(1778), 1, + anon_sym_LBRACE, + ACTIONS(1780), 1, + anon_sym_LT, + ACTIONS(1782), 1, + anon_sym_LPAREN, + ACTIONS(1784), 1, + anon_sym_LBRACK, + STATE(866), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1254), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [50670] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1786), 1, + sym_identifier, + STATE(1106), 1, sym_qualified_path, - STATE(1703), 5, + STATE(1750), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48726] = 6, + [50693] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(1068), 1, + STATE(1106), 1, sym_qualified_path, - STATE(1555), 5, + STATE(1268), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48749] = 6, + [50716] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(537), 5, + STATE(943), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48772] = 6, + [50739] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(940), 5, + STATE(944), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48795] = 6, + [50762] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(942), 5, + STATE(945), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48818] = 6, + [50785] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(515), 5, + STATE(622), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48841] = 6, + [50808] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(944), 5, + STATE(946), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48864] = 6, + [50831] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(1068), 1, + STATE(503), 1, sym_qualified_path, - STATE(1295), 5, + STATE(948), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48887] = 6, + [50854] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(945), 5, + STATE(950), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48910] = 6, + [50877] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(946), 5, + STATE(1215), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48933] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1758), 1, - anon_sym_COLON_COLON, - STATE(849), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(415), 7, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_LT, - anon_sym_LPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_LBRACK, - [48952] = 6, + [50900] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(924), 5, + STATE(625), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [48975] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1760), 1, - anon_sym_COLON_COLON, - STATE(849), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(419), 7, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_LT, - anon_sym_LPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_LBRACK, - [48994] = 6, + [50923] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1623), 5, + STATE(1463), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49017] = 2, + [50946] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1763), 9, + ACTIONS(1790), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46863,10 +48354,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49032] = 2, + [50961] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1765), 9, + ACTIONS(1792), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46876,362 +48367,355 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49047] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1767), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49062] = 8, + [50976] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1758), 1, - anon_sym_COLON_COLON, - ACTIONS(1769), 1, - anon_sym_LBRACE, - ACTIONS(1771), 1, - anon_sym_LT, - ACTIONS(1773), 1, + ACTIONS(1384), 1, + anon_sym_fn, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1775), 1, - anon_sym_LBRACK, - STATE(847), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1136), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [49089] = 6, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, + sym_qualified_path, + STATE(881), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [50999] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(891), 5, + STATE(617), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49112] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1777), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49127] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1779), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49142] = 6, + [51022] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(800), 5, + STATE(803), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49165] = 2, - ACTIONS(3), 1, + [51045] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1781), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1384), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49180] = 6, + ACTIONS(1386), 1, + anon_sym_LPAREN, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, + sym_qualified_path, + STATE(966), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51068] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, sym_qualified_path, - STATE(1469), 5, + STATE(942), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49203] = 6, + [51091] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1015), 5, + STATE(994), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49226] = 6, + [51114] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1776), 1, + anon_sym_COLON_COLON, + STATE(867), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(421), 7, + sym__statement_break, + anon_sym_LBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_LBRACK, + [51133] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1794), 1, + anon_sym_COLON_COLON, + STATE(867), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(425), 7, + sym__statement_break, + anon_sym_LBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_LBRACK, + [51152] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(1068), 1, + STATE(1106), 1, sym_qualified_path, - STATE(1391), 5, + STATE(1636), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49249] = 6, + [51175] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1786), 1, + sym_identifier, + STATE(1106), 1, sym_qualified_path, - STATE(1359), 5, + STATE(1295), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49272] = 6, + [51198] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(748), 5, + STATE(1020), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49295] = 6, + [51221] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1027), 5, + STATE(1696), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49318] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1783), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49333] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1785), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49348] = 6, + [51244] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(688), 5, + STATE(939), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49371] = 6, + [51267] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, sym_qualified_path, - STATE(983), 5, + STATE(964), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49394] = 6, + [51290] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(692), 5, + STATE(807), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49417] = 6, + [51313] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(1068), 1, + STATE(503), 1, sym_qualified_path, - STATE(1642), 5, + STATE(940), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49440] = 6, + [51336] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, sym_qualified_path, - STATE(1320), 5, + STATE(941), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49463] = 6, + [51359] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, sym_qualified_path, - STATE(1234), 5, + STATE(953), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49486] = 6, + [51382] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(702), 5, + STATE(813), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49509] = 2, + [51405] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1797), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51420] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1799), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51435] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1787), 9, + ACTIONS(1801), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47241,10 +48725,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49524] = 2, + [51450] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1789), 9, + ACTIONS(1803), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47254,180 +48738,206 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49539] = 6, + [51465] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(1068), 1, + STATE(503), 1, sym_qualified_path, - STATE(1333), 5, + STATE(957), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49562] = 6, + [51488] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(926), 5, + STATE(963), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49585] = 6, + [51511] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(438), 1, + STATE(1106), 1, sym_qualified_path, - STATE(950), 5, + STATE(1735), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49608] = 6, + [51534] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(928), 5, + STATE(704), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49631] = 6, + [51557] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(923), 5, + STATE(968), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49654] = 6, + [51580] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(438), 1, + STATE(1106), 1, sym_qualified_path, - STATE(933), 5, + STATE(1353), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49677] = 6, + [51603] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(943), 5, + STATE(715), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49700] = 6, + [51626] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(925), 5, + STATE(721), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49723] = 6, + [51649] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1805), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51664] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(991), 5, + STATE(1032), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49746] = 6, + [51687] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(931), 5, + STATE(731), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49769] = 2, + [51710] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1807), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51725] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1791), 9, + ACTIONS(1809), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47437,27 +48947,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49784] = 6, + [51740] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, + anon_sym_fn, + ACTIONS(1708), 1, + anon_sym_LPAREN, + STATE(691), 1, + sym_qualified_path, + STATE(1505), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51763] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(794), 5, + STATE(802), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49807] = 2, + [51786] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1793), 9, + ACTIONS(1811), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47467,27 +48994,78 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49822] = 6, + [51801] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1384), 1, + anon_sym_fn, + ACTIONS(1386), 1, + anon_sym_LPAREN, + ACTIONS(1788), 1, sym_identifier, - ACTIONS(1698), 1, + STATE(503), 1, + sym_qualified_path, + STATE(908), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51824] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, + anon_sym_fn, + ACTIONS(1708), 1, + anon_sym_LPAREN, + STATE(691), 1, + sym_qualified_path, + STATE(1017), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51847] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, + anon_sym_fn, + ACTIONS(1708), 1, + anon_sym_LPAREN, + STATE(691), 1, + sym_qualified_path, + STATE(1242), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51870] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1563), 5, + STATE(1129), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49845] = 2, + [51893] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1795), 9, + ACTIONS(1813), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47497,67 +49075,67 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49860] = 6, + [51908] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1347), 5, + STATE(1027), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49883] = 6, + [51931] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1144), 5, + STATE(1366), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49906] = 6, + [51954] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - STATE(696), 1, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, sym_qualified_path, - STATE(1366), 5, + STATE(858), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49929] = 6, + [51977] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, STATE(1386), 5, sym__type, @@ -47565,214 +49143,244 @@ static const uint16_t ts_small_parse_table[] = { sym_generic_type, sym_array_type, sym_type_identifier, - [49952] = 6, + [52000] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1815), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52015] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1384), 1, + anon_sym_fn, + ACTIONS(1386), 1, + anon_sym_LPAREN, + ACTIONS(1788), 1, sym_identifier, - ACTIONS(1698), 1, + STATE(503), 1, + sym_qualified_path, + STATE(859), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52038] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1387), 5, + STATE(1407), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49975] = 6, + [52061] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1396), 5, + STATE(1416), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49998] = 6, + [52084] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1004), 5, + STATE(998), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50021] = 6, + [52107] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(438), 1, + STATE(503), 1, sym_qualified_path, - STATE(852), 5, + STATE(935), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50044] = 6, + [52130] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1018), 5, + STATE(1054), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50067] = 6, + [52153] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1021), 5, + STATE(1038), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50090] = 6, + [52176] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1034), 5, + STATE(997), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50113] = 6, + [52199] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(975), 5, + STATE(1004), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50136] = 6, + [52222] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(976), 5, + STATE(1009), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50159] = 6, + [52245] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(977), 5, + STATE(1010), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50182] = 6, + [52268] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(978), 5, + STATE(1012), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50205] = 6, + [52291] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(792), 5, + STATE(1052), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50228] = 2, + [52314] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1797), 9, + ACTIONS(1817), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47782,146 +49390,125 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50243] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1696), 1, - sym_identifier, - ACTIONS(1698), 1, - anon_sym_fn, - ACTIONS(1700), 1, - anon_sym_LPAREN, - STATE(696), 1, - sym_qualified_path, - STATE(1496), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50266] = 6, - ACTIONS(298), 1, + [52329] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1819), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1360), 1, - anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, - sym_qualified_path, - STATE(866), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50289] = 6, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52344] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1502), 5, + STATE(1518), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50312] = 6, + [52367] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(1503), 5, + STATE(804), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50335] = 6, + [52390] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1372), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1374), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(1068), 1, + STATE(1106), 1, sym_qualified_path, - STATE(1472), 5, + STATE(1447), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50358] = 6, + [52413] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(798), 5, + STATE(1524), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50381] = 6, + [52436] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(939), 5, + STATE(1525), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50404] = 6, + [52459] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 1, + ACTIONS(1704), 1, + sym_identifier, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1360), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - sym_identifier, - STATE(438), 1, + STATE(691), 1, sym_qualified_path, - STATE(951), 5, + STATE(1448), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50427] = 2, + [52482] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1799), 9, + ACTIONS(1821), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47931,44 +49518,70 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50442] = 6, + [52497] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1386), 1, + ACTIONS(1384), 1, anon_sym_fn, - ACTIONS(1388), 1, + ACTIONS(1386), 1, anon_sym_LPAREN, - ACTIONS(1756), 1, + ACTIONS(1788), 1, sym_identifier, - STATE(1068), 1, + STATE(503), 1, sym_qualified_path, - STATE(1287), 5, + STATE(822), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50465] = 6, + [52520] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1823), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52535] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_fn, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_LPAREN, - STATE(696), 1, + STATE(691), 1, sym_qualified_path, - STATE(997), 5, + STATE(1022), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50488] = 2, + [52558] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1801), 9, + ACTIONS(1825), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52573] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1827), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47978,26 +49591,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50503] = 6, + [52588] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1384), 1, + anon_sym_fn, + ACTIONS(1386), 1, + anon_sym_LPAREN, + ACTIONS(1788), 1, + sym_identifier, + STATE(503), 1, + sym_qualified_path, + STATE(812), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52611] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - STATE(628), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1100), 1, + STATE(1108), 1, sym_type_arguments, - ACTIONS(1518), 4, + ACTIONS(1560), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, anon_sym_RBRACK, - [50525] = 2, + [52633] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(419), 8, + ACTIONS(425), 8, sym__statement_break, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -48006,5953 +49636,6003 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_where, anon_sym_LBRACK, - [50539] = 3, + [52647] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1833), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1831), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [52662] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1837), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1835), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [52677] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1841), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1839), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [52692] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1845), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1843), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [52707] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1849), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1847), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [52722] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1807), 2, + ACTIONS(1853), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1805), 5, + ACTIONS(1851), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50554] = 3, + [52737] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1811), 2, + ACTIONS(1857), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1809), 5, + ACTIONS(1855), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50569] = 3, + [52752] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1815), 2, + ACTIONS(1861), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1813), 5, + ACTIONS(1859), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50584] = 3, + [52767] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, + sym_identifier, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + STATE(1202), 1, + sym_type_arguments, + STATE(1064), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [52790] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1819), 2, + ACTIONS(1867), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1817), 5, + ACTIONS(1865), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50599] = 6, + [52805] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1821), 1, + ACTIONS(1869), 1, sym_identifier, - ACTIONS(1823), 1, + ACTIONS(1871), 1, anon_sym_COLON, - ACTIONS(1825), 1, + ACTIONS(1873), 1, sym_replayable, - STATE(1552), 1, + STATE(1630), 1, sym_multiplicity, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [50620] = 3, + [52826] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1829), 2, + ACTIONS(1877), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1827), 5, + ACTIONS(1875), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50635] = 7, + [52841] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - STATE(628), 1, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1211), 1, + STATE(1209), 1, sym_type_arguments, - STATE(1055), 2, + STATE(1070), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [50658] = 7, + [52864] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1871), 1, + anon_sym_COLON, + ACTIONS(1879), 1, sym_identifier, - STATE(628), 1, - aux_sym_qualified_path_repeat1, - STATE(1174), 1, - sym_type_arguments, - STATE(1064), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [50681] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1835), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1833), 5, + ACTIONS(1881), 1, + sym_replayable, + STATE(1639), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, - sym_identifier, - [50696] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, - sym_identifier, - STATE(628), 1, - aux_sym_qualified_path_repeat1, - STATE(1216), 1, - sym_type_arguments, - STATE(1090), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [50719] = 3, + [52885] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1839), 2, + ACTIONS(1885), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1837), 5, + ACTIONS(1883), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50734] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1841), 1, - sym_identifier, - ACTIONS(1843), 1, - anon_sym_COLON, - ACTIONS(1845), 1, - sym_replayable, - STATE(1349), 1, - sym_multiplicity, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [50755] = 6, + [52900] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1769), 1, + ACTIONS(1778), 1, anon_sym_LBRACE, - ACTIONS(1771), 1, + ACTIONS(1780), 1, anon_sym_LT, - ACTIONS(1773), 1, + ACTIONS(1782), 1, anon_sym_LPAREN, - ACTIONS(1775), 1, + ACTIONS(1784), 1, anon_sym_LBRACK, - ACTIONS(1136), 3, + ACTIONS(1254), 3, sym__statement_break, anon_sym_PIPE, anon_sym_where, - [50776] = 6, + [52921] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1758), 1, + ACTIONS(1776), 1, anon_sym_COLON_COLON, - ACTIONS(1769), 1, + ACTIONS(1778), 1, anon_sym_LBRACE, - ACTIONS(1773), 1, + ACTIONS(1782), 1, anon_sym_LPAREN, - STATE(847), 1, + STATE(866), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1136), 3, + ACTIONS(1254), 3, sym__statement_break, anon_sym_PIPE, anon_sym_where, - [50797] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, - sym_identifier, - STATE(628), 1, - aux_sym_qualified_path_repeat1, - STATE(1196), 1, - sym_type_arguments, - STATE(1076), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [50820] = 7, + [52942] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1887), 1, sym_identifier, - STATE(628), 1, - aux_sym_qualified_path_repeat1, - STATE(1226), 1, - sym_type_arguments, - STATE(1082), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [50843] = 3, + ACTIONS(1889), 1, + anon_sym_COLON, + ACTIONS(1891), 1, + sym_replayable, + STATE(1609), 1, + sym_multiplicity, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [52963] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1849), 2, + ACTIONS(1895), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1847), 5, + ACTIONS(1893), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50858] = 3, - ACTIONS(3), 1, + [52978] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1853), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1851), 5, + ACTIONS(1897), 1, + sym_identifier, + ACTIONS(1899), 1, + anon_sym_COLON, + ACTIONS(1901), 1, + sym_replayable, + STATE(1620), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, - sym_identifier, - [50873] = 7, + [52999] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - STATE(628), 1, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1228), 1, + STATE(1236), 1, sym_type_arguments, - STATE(1048), 2, + STATE(1098), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [50896] = 3, - ACTIONS(3), 1, + [53022] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1857), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1855), 5, + ACTIONS(1903), 1, + sym_identifier, + ACTIONS(1905), 1, + anon_sym_COLON, + ACTIONS(1907), 1, + sym_replayable, + STATE(1472), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, + [53043] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - [50911] = 3, - ACTIONS(3), 1, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + STATE(1239), 1, + sym_type_arguments, + STATE(1100), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53066] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1861), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1859), 5, + ACTIONS(1899), 1, + anon_sym_COLON, + ACTIONS(1909), 1, + sym_identifier, + ACTIONS(1911), 1, + sym_replayable, + STATE(1629), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, - sym_identifier, - [50926] = 3, + [53087] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1865), 2, + ACTIONS(1915), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1863), 5, + ACTIONS(1913), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50941] = 3, + [53102] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1869), 2, + ACTIONS(1919), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1867), 5, + ACTIONS(1917), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50956] = 3, + [53117] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, + sym_identifier, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + STATE(1154), 1, + sym_type_arguments, + STATE(1114), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53140] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1873), 2, + ACTIONS(1923), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1871), 5, + ACTIONS(1921), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [50971] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1843), 1, - anon_sym_COLON, - ACTIONS(1875), 1, - sym_identifier, - ACTIONS(1877), 1, - sym_replayable, - STATE(1692), 1, - sym_multiplicity, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [50992] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1879), 1, - sym_identifier, - ACTIONS(1881), 1, - anon_sym_COLON, - ACTIONS(1883), 1, - sym_replayable, - STATE(1436), 1, - sym_multiplicity, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [51013] = 6, + [53155] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1885), 1, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - ACTIONS(1887), 1, - anon_sym_COLON, - ACTIONS(1889), 1, - sym_replayable, - STATE(1441), 1, - sym_multiplicity, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [51034] = 3, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + STATE(1261), 1, + sym_type_arguments, + STATE(1077), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53178] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1893), 2, + ACTIONS(1927), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1891), 5, + ACTIONS(1925), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [51049] = 3, - ACTIONS(3), 1, + [53193] = 4, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1897), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1895), 5, + ACTIONS(1829), 1, + anon_sym_LT2, + STATE(1108), 1, + sym_type_arguments, + ACTIONS(1560), 4, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + [53209] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(1931), 1, + anon_sym_EQ, + ACTIONS(1933), 1, + anon_sym_DASH_GT, + ACTIONS(1935), 1, + anon_sym_BANG, + STATE(1126), 1, + sym_effect_set, + STATE(1556), 1, + sym_block, + [53231] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1939), 1, + anon_sym_COLON, + ACTIONS(1937), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [51064] = 6, + [53245] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1887), 1, - anon_sym_COLON, - ACTIONS(1899), 1, + ACTIONS(1941), 1, sym_identifier, - ACTIONS(1901), 1, + ACTIONS(1943), 1, sym_replayable, - STATE(1450), 1, + STATE(962), 1, sym_multiplicity, - ACTIONS(1560), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [51085] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1905), 1, - anon_sym_EQ, - ACTIONS(1907), 1, - anon_sym_DASH_GT, - ACTIONS(1909), 1, - anon_sym_BANG, - STATE(1112), 1, - sym_effect_set, - STATE(1451), 1, - sym_block, - [51107] = 7, + [53263] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1911), 1, + ACTIONS(1945), 1, anon_sym_EQ, - ACTIONS(1913), 1, + ACTIONS(1947), 1, anon_sym_DASH_GT, - STATE(1165), 1, + STATE(1253), 1, sym_effect_set, - STATE(1392), 1, + STATE(1553), 1, sym_block, - [51129] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1758), 1, - anon_sym_COLON_COLON, - ACTIONS(1771), 1, - anon_sym_LT, - ACTIONS(1775), 1, - anon_sym_LBRACK, - STATE(847), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(961), 2, - sym__statement_break, - anon_sym_where, - [51149] = 7, + [53285] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(1917), 1, + ACTIONS(1951), 1, anon_sym_EQ, - ACTIONS(1919), 1, + ACTIONS(1953), 1, anon_sym_DASH_GT, - STATE(685), 1, + STATE(689), 1, sym_block, - STATE(1181), 1, + STATE(1125), 1, sym_effect_set, - [51171] = 7, + [53307] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1921), 1, - anon_sym_EQ, - ACTIONS(1923), 1, - anon_sym_DASH_GT, - STATE(1217), 1, - sym_effect_set, - STATE(1569), 1, - sym_block, - [51193] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1925), 1, + ACTIONS(1955), 1, anon_sym_EQ, - ACTIONS(1927), 1, + ACTIONS(1957), 1, anon_sym_DASH_GT, - STATE(1113), 1, - sym_effect_set, - STATE(1454), 1, + STATE(707), 1, sym_block, - [51215] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1929), 1, - anon_sym_EQ, - ACTIONS(1931), 1, - anon_sym_DASH_GT, - STATE(1110), 1, + STATE(1150), 1, sym_effect_set, - STATE(1416), 1, - sym_block, - [51237] = 7, + [53329] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(1933), 1, + ACTIONS(1959), 1, anon_sym_EQ, - ACTIONS(1935), 1, + ACTIONS(1961), 1, anon_sym_DASH_GT, - STATE(719), 1, + STATE(738), 1, sym_block, - STATE(1162), 1, + STATE(1168), 1, sym_effect_set, - [51259] = 7, + [53351] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(1937), 1, + ACTIONS(1963), 1, anon_sym_EQ, - ACTIONS(1939), 1, + ACTIONS(1965), 1, anon_sym_DASH_GT, - STATE(681), 1, + STATE(712), 1, sym_block, - STATE(1178), 1, + STATE(1153), 1, sym_effect_set, - [51281] = 2, + [53373] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1785), 6, - anon_sym_DOT, + ACTIONS(1929), 1, anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - sym_identifier, - [51293] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1941), 1, - sym_identifier, - ACTIONS(1943), 1, - sym_replayable, - STATE(952), 1, - sym_multiplicity, - ACTIONS(1560), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [51311] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, - ACTIONS(1945), 1, + ACTIONS(1967), 1, anon_sym_EQ, - ACTIONS(1947), 1, + ACTIONS(1969), 1, anon_sym_DASH_GT, - STATE(695), 1, - sym_block, - STATE(1185), 1, + STATE(1188), 1, sym_effect_set, - [51333] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - STATE(1100), 1, - sym_type_arguments, - ACTIONS(1518), 4, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - [51349] = 7, + STATE(1378), 1, + sym_block, + [53395] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(1971), 1, anon_sym_EQ, - ACTIONS(1951), 1, + ACTIONS(1973), 1, anon_sym_DASH_GT, - STATE(699), 1, + STATE(756), 1, sym_block, - STATE(1186), 1, + STATE(1135), 1, sym_effect_set, - [51371] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1955), 1, - anon_sym_COLON, - ACTIONS(1953), 5, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - sym_identifier, - [51385] = 7, + [53417] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1957), 1, - anon_sym_EQ, - ACTIONS(1959), 1, - anon_sym_DASH_GT, - STATE(1137), 1, - sym_effect_set, - STATE(1456), 1, - sym_block, - [51407] = 7, + ACTIONS(1776), 1, + anon_sym_COLON_COLON, + ACTIONS(1780), 1, + anon_sym_LT, + ACTIONS(1784), 1, + anon_sym_LBRACK, + STATE(866), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(982), 2, + sym__statement_break, + anon_sym_where, + [53437] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1961), 1, + ACTIONS(1975), 1, anon_sym_EQ, - ACTIONS(1963), 1, + ACTIONS(1977), 1, anon_sym_DASH_GT, - STATE(1143), 1, + STATE(1184), 1, sym_effect_set, - STATE(1550), 1, + STATE(1717), 1, sym_block, - [51429] = 7, + [53459] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(1965), 1, + ACTIONS(1979), 1, anon_sym_EQ, - ACTIONS(1967), 1, + ACTIONS(1981), 1, anon_sym_DASH_GT, - STATE(740), 1, + STATE(695), 1, sym_block, - STATE(1171), 1, + STATE(1139), 1, sym_effect_set, - [51451] = 7, + [53481] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1969), 1, + ACTIONS(1983), 1, anon_sym_EQ, - ACTIONS(1971), 1, + ACTIONS(1985), 1, anon_sym_DASH_GT, STATE(1128), 1, sym_effect_set, - STATE(1418), 1, - sym_block, - [51473] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, - ACTIONS(1973), 1, - anon_sym_EQ, - ACTIONS(1975), 1, - anon_sym_DASH_GT, - STATE(707), 1, - sym_block, - STATE(1189), 1, - sym_effect_set, - [51495] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, - ACTIONS(1977), 1, - anon_sym_EQ, - ACTIONS(1979), 1, - anon_sym_DASH_GT, - STATE(735), 1, + STATE(1532), 1, sym_block, - STATE(1168), 1, - sym_effect_set, - [51517] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1672), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [51534] = 6, + [53503] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1985), 1, - anon_sym_EQ, - STATE(704), 1, - sym_block, - STATE(1188), 1, - sym_effect_set, - [51553] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, ACTIONS(1987), 1, anon_sym_EQ, - STATE(711), 1, - sym_block, - STATE(1190), 1, - sym_effect_set, - [51572] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, ACTIONS(1989), 1, - anon_sym_EQ, - STATE(712), 1, - sym_block, - STATE(1191), 1, + anon_sym_DASH_GT, + STATE(1156), 1, sym_effect_set, - [51591] = 6, + STATE(1653), 1, + sym_block, + [53525] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, ACTIONS(1991), 1, anon_sym_EQ, - STATE(717), 1, + ACTIONS(1993), 1, + anon_sym_DASH_GT, + STATE(725), 1, sym_block, - STATE(1193), 1, + STATE(1160), 1, sym_effect_set, - [51610] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1377), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [51627] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1702), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [51644] = 6, + [53547] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1993), 1, + ACTIONS(1809), 6, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, sym_identifier, - ACTIONS(1995), 1, - sym_string, - STATE(1042), 1, - sym_namespace_name, - STATE(1070), 1, - sym_import_target, - STATE(1358), 1, - sym_legacy_import_path, - [51663] = 4, + [53559] = 7, ACTIONS(298), 1, sym_line_comment, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(1995), 1, + anon_sym_EQ, ACTIONS(1997), 1, - anon_sym_DOT, - STATE(1111), 1, - aux_sym_legacy_import_path_repeat1, - ACTIONS(1999), 3, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [51678] = 6, + anon_sym_DASH_GT, + STATE(728), 1, + sym_block, + STATE(1161), 1, + sym_effect_set, + [53581] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2001), 1, + ACTIONS(1999), 1, anon_sym_EQ, - STATE(1117), 1, + ACTIONS(2001), 1, + anon_sym_DASH_GT, + STATE(1234), 1, sym_effect_set, - STATE(1547), 1, + STATE(1561), 1, sym_block, - [51697] = 5, + [53603] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1527), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [51714] = 5, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2003), 1, + anon_sym_EQ, + ACTIONS(2005), 1, + anon_sym_DASH_GT, + STATE(1232), 1, + sym_effect_set, + STATE(1384), 1, + sym_block, + [53625] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(2003), 1, + ACTIONS(2007), 1, anon_sym_COLON, - STATE(1007), 1, + STATE(1037), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1580), 2, + ACTIONS(1599), 2, anon_sym_LBRACE, anon_sym_PLUS, - [51731] = 5, + [53642] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2007), 1, + ACTIONS(2011), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1618), 1, + STATE(1427), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [51748] = 5, + [53659] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1606), 1, + STATE(1365), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [51765] = 5, + [53676] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2009), 1, + ACTIONS(2017), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1357), 1, + STATE(1584), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [51782] = 5, + [53693] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2019), 1, + anon_sym_EQ, + STATE(1191), 1, + sym_effect_set, + STATE(1733), 1, + sym_block, + [53712] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, + sym_identifier, + STATE(1209), 1, + sym_type_arguments, + STATE(1070), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53729] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2021), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1717), 1, + STATE(1467), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [51799] = 6, + [53746] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2013), 1, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2023), 1, anon_sym_EQ, - STATE(1122), 1, - sym_effect_set, - STATE(1369), 1, + STATE(730), 1, sym_block, - [51818] = 6, + STATE(1163), 1, + sym_effect_set, + [53765] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2015), 1, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2025), 1, anon_sym_EQ, - STATE(1225), 1, - sym_effect_set, - STATE(1624), 1, + STATE(702), 1, sym_block, - [51837] = 5, + STATE(1146), 1, + sym_effect_set, + [53784] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2017), 1, - anon_sym_PIPE, - STATE(1087), 1, - sym_parameter, - STATE(1526), 1, - sym_parameter_list, - ACTIONS(2005), 2, - anon_sym__, + ACTIONS(2013), 1, sym_identifier, - [51854] = 5, + STATE(1195), 1, + sym_type_parameter, + STATE(1498), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [53801] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2027), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1544), 1, + STATE(1703), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [51871] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, - sym_identifier, - STATE(1211), 1, - sym_type_arguments, - STATE(1055), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [51888] = 5, + [53818] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1196), 1, - sym_type_arguments, - STATE(1076), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [51905] = 5, + STATE(1195), 1, + sym_type_parameter, + STATE(1399), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [53835] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1667), 1, + STATE(1617), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [51922] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(2021), 1, - anon_sym_EQ, - STATE(1145), 1, - sym_effect_set, - STATE(1574), 1, - sym_block, - [51941] = 5, + [53852] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2023), 1, + ACTIONS(2029), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1559), 1, + STATE(1610), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [51958] = 5, + [53869] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, - sym_identifier, - STATE(1216), 1, - sym_type_arguments, - STATE(1090), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [51975] = 5, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2031), 1, + anon_sym_EQ, + STATE(735), 1, + sym_block, + STATE(1165), 1, + sym_effect_set, + [53888] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2025), 1, - anon_sym_RPAREN, - STATE(1087), 1, - sym_parameter, - STATE(1585), 1, - sym_parameter_list, - ACTIONS(2005), 2, - anon_sym__, - sym_identifier, - [51992] = 5, + ACTIONS(1778), 1, + anon_sym_LBRACE, + ACTIONS(1782), 1, + anon_sym_LPAREN, + ACTIONS(1254), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [53903] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1534), 1, + STATE(1502), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52009] = 5, + [53920] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1633), 1, + STATE(1478), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52026] = 5, + [53937] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2027), 1, + ACTIONS(2033), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1594), 1, + STATE(1619), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [52043] = 6, + [53954] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2029), 1, + ACTIONS(2035), 1, anon_sym_EQ, - STATE(746), 1, + STATE(742), 1, sym_block, - STATE(1175), 1, + STATE(1169), 1, sym_effect_set, - [52062] = 5, + [53973] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2031), 1, - anon_sym_RPAREN, - STATE(1087), 1, - sym_parameter, - STATE(1653), 1, - sym_parameter_list, - ACTIONS(2005), 2, - anon_sym__, - sym_identifier, - [52079] = 5, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2037), 1, + anon_sym_EQ, + STATE(743), 1, + sym_block, + STATE(1170), 1, + sym_effect_set, + [53992] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2033), 1, + ACTIONS(2039), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1600), 1, + STATE(1625), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [52096] = 5, + [54009] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(2035), 1, - anon_sym_COLON, - STATE(561), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1654), 2, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(1949), 1, anon_sym_LBRACE, - anon_sym_PLUS, - [52113] = 5, + ACTIONS(2041), 1, + anon_sym_EQ, + STATE(747), 1, + sym_block, + STATE(1171), 1, + sym_effect_set, + [54028] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1589), 1, + STATE(1438), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52130] = 6, + [54045] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, + sym_type_parameter, + STATE(1470), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [54062] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, + sym_type_parameter, + STATE(1622), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [54079] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2043), 1, + sym_identifier, + ACTIONS(2045), 1, + sym_string, + STATE(1066), 1, + sym_import_target, + STATE(1068), 1, + sym_namespace_name, + STATE(1668), 1, + sym_legacy_import_path, + [54098] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2037), 1, + ACTIONS(2047), 1, anon_sym_EQ, - STATE(1157), 1, + STATE(1259), 1, sym_effect_set, - STATE(1693), 1, + STATE(1414), 1, sym_block, - [52149] = 4, + [54117] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1769), 1, - anon_sym_LBRACE, - ACTIONS(1773), 1, - anon_sym_LPAREN, - ACTIONS(1136), 3, - sym__statement_break, + ACTIONS(2049), 1, anon_sym_PIPE, - anon_sym_where, - [52164] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2039), 1, - anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1620), 1, + STATE(1634), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [52181] = 5, + [54134] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2041), 1, + ACTIONS(2051), 1, anon_sym_RPAREN, - STATE(1087), 1, + STATE(1117), 1, sym_parameter, - STATE(1578), 1, + STATE(1646), 1, sym_parameter_list, - ACTIONS(2005), 2, + ACTIONS(2009), 2, anon_sym__, sym_identifier, - [52198] = 5, + [54151] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2053), 1, + anon_sym_EQ, + STATE(1193), 1, + sym_effect_set, + STATE(1746), 1, + sym_block, + [54170] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - STATE(1226), 1, + STATE(1236), 1, sym_type_arguments, - STATE(1082), 2, + STATE(1098), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52215] = 5, + [54187] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2043), 1, - anon_sym_PIPE, - STATE(1087), 1, - sym_parameter, - STATE(1365), 1, - sym_parameter_list, - ACTIONS(2005), 2, - anon_sym__, - sym_identifier, - [52232] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2045), 1, + ACTIONS(2055), 1, anon_sym_EQ, - STATE(1139), 1, + STATE(1204), 1, sym_effect_set, - STATE(1468), 1, + STATE(1434), 1, sym_block, - [52251] = 6, + [54206] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, - anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2047), 1, - anon_sym_DOT, - STATE(628), 1, - aux_sym_qualified_path_repeat1, - STATE(1566), 1, + ACTIONS(2057), 1, + anon_sym_RPAREN, + STATE(1117), 1, + sym_parameter, + STATE(1624), 1, + sym_parameter_list, + ACTIONS(2009), 2, + anon_sym__, + sym_identifier, + [54223] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, + sym_identifier, + STATE(1154), 1, sym_type_arguments, - [52270] = 5, + STATE(1114), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54240] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - STATE(1228), 1, + STATE(1239), 1, sym_type_arguments, - STATE(1048), 2, + STATE(1100), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52287] = 6, + [54257] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(2059), 1, + anon_sym_PIPE, + STATE(1117), 1, + sym_parameter, + STATE(1413), 1, + sym_parameter_list, + ACTIONS(2009), 2, + anon_sym__, + sym_identifier, + [54274] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2049), 1, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2061), 1, anon_sym_EQ, - STATE(750), 1, - sym_block, - STATE(1183), 1, + STATE(1145), 1, sym_effect_set, - [52306] = 6, + STATE(1574), 1, + sym_block, + [54293] = 6, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(833), 1, + ACTIONS(859), 1, anon_sym_type, - STATE(224), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - STATE(720), 1, + STATE(748), 1, sym_type_declaration, - STATE(1506), 1, + STATE(1702), 1, sym_doc_comment, - [52325] = 5, + [54312] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1656), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [52342] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2051), 1, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2063), 1, anon_sym_EQ, - STATE(690), 1, - sym_block, - STATE(1184), 1, + STATE(1131), 1, sym_effect_set, - [52361] = 6, + STATE(1628), 1, + sym_block, + [54331] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2065), 1, + anon_sym_DOT, + STATE(825), 1, + aux_sym_qualified_path_repeat1, + STATE(1648), 1, + sym_type_arguments, + [54350] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2067), 1, + anon_sym_DOT, + STATE(1224), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(2069), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [54365] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(1909), 1, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2053), 1, + ACTIONS(2071), 1, anon_sym_EQ, - STATE(1149), 1, + STATE(1246), 1, sym_effect_set, - STATE(1612), 1, + STATE(1400), 1, sym_block, - [52380] = 5, + [54384] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2073), 1, + anon_sym_PIPE, + STATE(1117), 1, + sym_parameter, + STATE(1550), 1, + sym_parameter_list, + ACTIONS(2009), 2, + anon_sym__, sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1561), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [52397] = 5, + [54401] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, STATE(1586), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52414] = 5, + [54418] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1348), 1, + STATE(1611), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52431] = 5, + [54435] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2075), 1, + anon_sym_RPAREN, + STATE(1117), 1, + sym_parameter, + STATE(1569), 1, + sym_parameter_list, + ACTIONS(2009), 2, + anon_sym__, sym_identifier, - STATE(1142), 1, - sym_type_parameter, - STATE(1670), 1, - sym_type_parameter_list, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [52448] = 6, + [54452] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1744), 1, + anon_sym_COLON_COLON, + ACTIONS(2077), 1, + anon_sym_COLON, + STATE(761), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1634), 2, anon_sym_LBRACE, - ACTIONS(1909), 1, + anon_sym_PLUS, + [54469] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1935), 1, anon_sym_BANG, - ACTIONS(2055), 1, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2079), 1, anon_sym_EQ, - STATE(1140), 1, - sym_effect_set, - STATE(1481), 1, + STATE(719), 1, sym_block, - [52467] = 6, + STATE(1157), 1, + sym_effect_set, + [54488] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, + sym_identifier, + STATE(1202), 1, + sym_type_arguments, + STATE(1064), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54505] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2057), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2081), 1, anon_sym_DOT, - STATE(628), 1, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1699), 1, + STATE(1725), 1, sym_type_arguments, - [52486] = 5, + [54524] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1666), 1, + STATE(1692), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52503] = 6, - ACTIONS(3), 1, + [54541] = 5, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(833), 1, - anon_sym_type, - STATE(224), 1, - aux_sym_doc_comment_repeat1, - STATE(729), 1, - sym_type_declaration, - STATE(1506), 1, - sym_doc_comment, - [52522] = 5, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, + sym_type_parameter, + STATE(1485), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [54558] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2083), 1, + anon_sym_RPAREN, + STATE(1117), 1, + sym_parameter, + STATE(1374), 1, + sym_parameter_list, + ACTIONS(2009), 2, + anon_sym__, sym_identifier, - STATE(1142), 1, + [54575] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, + sym_type_parameter, + STATE(1698), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [54592] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, sym_type_parameter, - STATE(1673), 1, + STATE(1699), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52539] = 5, + [54609] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1675), 1, + STATE(1701), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52556] = 6, + [54626] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1267), 1, + ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2059), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2085), 1, anon_sym_DOT, - STATE(628), 1, + STATE(825), 1, aux_sym_qualified_path_repeat1, - STATE(1710), 1, + STATE(1736), 1, sym_type_arguments, - [52575] = 6, + [54645] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1909), 1, - anon_sym_BANG, - ACTIONS(1915), 1, - anon_sym_LBRACE, - ACTIONS(2061), 1, - anon_sym_EQ, - STATE(701), 1, - sym_block, - STATE(1187), 1, - sym_effect_set, - [52594] = 5, + ACTIONS(2013), 1, + sym_identifier, + STATE(1195), 1, + sym_type_parameter, + STATE(1465), 1, + sym_type_parameter_list, + ACTIONS(2015), 2, + anon_sym_in, + anon_sym_out, + [54662] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1701), 1, + STATE(1727), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52611] = 5, + [54679] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1981), 1, + ACTIONS(2013), 1, sym_identifier, - STATE(1142), 1, + STATE(1195), 1, sym_type_parameter, - STATE(1704), 1, + STATE(1730), 1, sym_type_parameter_list, - ACTIONS(1983), 2, + ACTIONS(2015), 2, anon_sym_in, anon_sym_out, - [52628] = 5, + [54696] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(1831), 1, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(1863), 1, sym_identifier, - STATE(1174), 1, + STATE(1261), 1, sym_type_arguments, - STATE(1064), 2, + STATE(1077), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52645] = 5, + [54713] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2063), 1, - anon_sym_PIPE, - STATE(1087), 1, - sym_parameter, - STATE(1609), 1, - sym_parameter_list, - ACTIONS(2005), 2, - anon_sym__, - sym_identifier, - [52662] = 5, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(2087), 1, + anon_sym_EQ, + STATE(1229), 1, + sym_effect_set, + STATE(1441), 1, + sym_block, + [54732] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(859), 1, + anon_sym_type, + STATE(226), 1, + aux_sym_doc_comment_repeat1, + STATE(751), 1, + sym_type_declaration, + STATE(1702), 1, + sym_doc_comment, + [54751] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2065), 1, - sym_identifier, - STATE(965), 1, - sym_qualified_path, - STATE(1229), 1, - sym_effect_ref, - STATE(1626), 1, - sym_effect_list, - [52678] = 4, + ACTIONS(1935), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2089), 1, + anon_sym_EQ, + STATE(714), 1, + sym_block, + STATE(1155), 1, + sym_effect_set, + [54770] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2013), 1, sym_identifier, - ACTIONS(2069), 1, + STATE(1329), 1, + sym_type_parameter, + ACTIONS(2015), 2, anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [52692] = 4, + anon_sym_out, + [54784] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2071), 1, - anon_sym_COLON_COLON, - STATE(1053), 1, - aux_sym_import_target_repeat1, - ACTIONS(2074), 2, - sym__statement_break, - anon_sym_as, - [52706] = 4, + ACTIONS(2091), 1, + anon_sym_COMMA, + STATE(1056), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2094), 2, + anon_sym_GT, + anon_sym_RPAREN, + [54798] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2076), 1, - anon_sym_COLON_COLON, - STATE(1041), 1, - aux_sym_import_target_repeat1, - ACTIONS(2079), 2, + ACTIONS(2096), 1, + anon_sym_PIPE, + STATE(1060), 1, + aux_sym_union_type_repeat1, + ACTIONS(1341), 2, sym__statement_break, - anon_sym_as, - [52720] = 2, + anon_sym_where, + [54812] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2081), 4, + ACTIONS(2098), 1, anon_sym_COMMA, + STATE(1056), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2100), 2, + anon_sym_GT, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [52730] = 4, + [54826] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2102), 1, sym_identifier, - ACTIONS(2083), 1, - anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [52744] = 4, + ACTIONS(2104), 1, + anon_sym_EQ_GT, + STATE(1133), 1, + aux_sym_handler_params_repeat1, + STATE(1544), 1, + sym_handler_params, + [54842] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2085), 1, + ACTIONS(2106), 1, anon_sym_PIPE, - STATE(1045), 1, + STATE(1060), 1, aux_sym_union_type_repeat1, - ACTIONS(1321), 2, + ACTIONS(1332), 2, sym__statement_break, anon_sym_where, - [52758] = 5, + [54856] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2065), 1, + ACTIONS(2102), 1, sym_identifier, - STATE(965), 1, - sym_qualified_path, - STATE(1229), 1, - sym_effect_ref, - STATE(1420), 1, - sym_effect_list, - [52774] = 2, + ACTIONS(2109), 1, + anon_sym_EQ_GT, + STATE(1133), 1, + aux_sym_handler_params_repeat1, + STATE(1560), 1, + sym_handler_params, + [54872] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2088), 4, + ACTIONS(2111), 1, anon_sym_COMMA, + STATE(1062), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1028), 2, anon_sym_RPAREN, anon_sym_RBRACK, - anon_sym_EQ_GT, - [52784] = 4, + [54886] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2114), 1, sym_identifier, - ACTIONS(2090), 1, + ACTIONS(2116), 1, anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [52798] = 4, + STATE(1088), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [54900] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2092), 1, + ACTIONS(2120), 1, anon_sym_in, - STATE(1089), 2, + STATE(1084), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52812] = 4, + [54914] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2094), 1, + ACTIONS(2122), 1, anon_sym_in, - STATE(1089), 2, + STATE(1084), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52826] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2096), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [52836] = 2, + [54928] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2098), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [52846] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2100), 1, + ACTIONS(2124), 1, anon_sym_COLON_COLON, - STATE(1053), 1, - aux_sym_import_target_repeat1, - ACTIONS(2103), 2, - sym__statement_break, + ACTIONS(2126), 1, anon_sym_as, - [52860] = 5, + ACTIONS(2128), 1, + sym__statement_break, + STATE(1526), 1, + sym_import_tail, + [54944] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, + ACTIONS(2130), 1, sym_identifier, - ACTIONS(2107), 1, + ACTIONS(2132), 1, anon_sym_RPAREN, - STATE(1116), 1, + STATE(1254), 1, sym_extern_parameter, - STATE(1465), 1, + STATE(1391), 1, sym_extern_parameter_list, - [52876] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2067), 1, - sym_identifier, - ACTIONS(2109), 1, - anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [52890] = 5, + [54960] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2111), 1, - sym_identifier, - ACTIONS(2113), 1, - anon_sym_RBRACE, - STATE(1108), 1, - sym_import_member, - STATE(1610), 1, - sym_import_member_list, - [52906] = 2, + ACTIONS(2134), 1, + anon_sym_COLON_COLON, + STATE(1092), 1, + aux_sym_import_target_repeat1, + ACTIONS(2137), 2, + sym__statement_break, + anon_sym_as, + [54974] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2115), 4, + ACTIONS(2139), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [52916] = 5, + [54984] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2065), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2117), 1, - anon_sym_LBRACK, - STATE(965), 1, - sym_qualified_path, - STATE(1263), 1, - sym_effect_ref, - [52932] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2119), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [52942] = 4, + ACTIONS(2141), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54998] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2121), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2123), 1, + ACTIONS(2143), 1, anon_sym_in, - STATE(1086), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [52956] = 5, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55012] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, + ACTIONS(2130), 1, sym_identifier, - ACTIONS(2125), 1, + ACTIONS(2145), 1, anon_sym_RPAREN, - STATE(1116), 1, + STATE(1254), 1, sym_extern_parameter, - STATE(1536), 1, + STATE(1387), 1, sym_extern_parameter_list, - [52972] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1981), 1, - sym_identifier, - STATE(1252), 1, - sym_type_parameter, - ACTIONS(1983), 2, - anon_sym_in, - anon_sym_out, - [52986] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2127), 1, - anon_sym_COMMA, - STATE(1063), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2130), 2, - anon_sym_RPAREN, - anon_sym_PIPE, - [53000] = 4, + [55028] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2147), 1, sym_identifier, - ACTIONS(2132), 1, - anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53014] = 5, + ACTIONS(2149), 1, + anon_sym_RBRACE, + STATE(1152), 1, + sym_import_member, + STATE(1508), 1, + sym_import_member_list, + [55044] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2134), 1, + ACTIONS(2151), 1, sym_identifier, - ACTIONS(2136), 1, + ACTIONS(2153), 1, anon_sym_LBRACK, - STATE(808), 1, + STATE(818), 1, sym_qualified_path, - STATE(857), 1, + STATE(891), 1, sym_effect_ref, - [53030] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2138), 1, - anon_sym_COMMA, - STATE(1066), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2141), 2, - anon_sym_GT, - anon_sym_RPAREN, - [53044] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2143), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [53054] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1771), 1, - anon_sym_LT, - ACTIONS(1775), 1, - anon_sym_LBRACK, - ACTIONS(961), 2, - sym__statement_break, - anon_sym_where, - [53068] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2147), 1, - anon_sym_COLON, - ACTIONS(2145), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_PIPE, - [53080] = 5, + [55060] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2149), 1, + ACTIONS(2155), 1, anon_sym_COLON_COLON, - ACTIONS(2151), 1, - anon_sym_as, - ACTIONS(2153), 1, - sym__statement_break, - STATE(1444), 1, - sym_import_tail, - [53096] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2155), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [53106] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2157), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [53116] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2105), 1, - sym_identifier, - ACTIONS(2159), 1, - anon_sym_RPAREN, - STATE(1116), 1, - sym_extern_parameter, - STATE(1371), 1, - sym_extern_parameter_list, - [53132] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2161), 1, - anon_sym_PIPE, - STATE(1045), 1, - aux_sym_union_type_repeat1, - ACTIONS(1326), 2, + STATE(1075), 1, + aux_sym_import_target_repeat1, + ACTIONS(2158), 2, sym__statement_break, - anon_sym_where, - [53146] = 4, + anon_sym_as, + [55074] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2163), 1, + ACTIONS(2160), 1, anon_sym_in, - STATE(1089), 2, + STATE(1084), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53160] = 4, + [55088] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2165), 1, + ACTIONS(2162), 1, anon_sym_in, - STATE(1089), 2, + STATE(1084), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53174] = 5, + [55102] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, - sym_identifier, - ACTIONS(2167), 1, + ACTIONS(2166), 1, + anon_sym_COLON, + ACTIONS(2164), 3, + anon_sym_COMMA, anon_sym_RPAREN, - STATE(1116), 1, - sym_extern_parameter, - STATE(1576), 1, - sym_extern_parameter_list, - [53190] = 5, + anon_sym_PIPE, + [55114] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, + ACTIONS(2130), 1, sym_identifier, - ACTIONS(2169), 1, + ACTIONS(2168), 1, anon_sym_RPAREN, - STATE(1116), 1, + STATE(1254), 1, sym_extern_parameter, - STATE(1521), 1, + STATE(1432), 1, sym_extern_parameter_list, - [53206] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2121), 1, - sym_identifier, - ACTIONS(2171), 1, - anon_sym_in, - STATE(1086), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [53220] = 4, + [55130] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2121), 1, + ACTIONS(2118), 1, sym_identifier, - ACTIONS(2173), 1, + ACTIONS(2170), 1, anon_sym_in, - STATE(1086), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [53234] = 2, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55144] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2175), 4, + ACTIONS(2172), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [53244] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2067), 1, - sym_identifier, - ACTIONS(2177), 1, - anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53258] = 2, + [55154] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(547), 4, + ACTIONS(2174), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [53268] = 4, + [55164] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2176), 1, anon_sym_COMMA, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1026), 2, + STATE(1083), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2179), 2, anon_sym_RPAREN, - anon_sym_RBRACK, - [53282] = 5, + anon_sym_PIPE, + [55178] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2182), 1, + ACTIONS(2181), 1, sym_identifier, ACTIONS(2184), 1, - anon_sym_EQ_GT, - STATE(1179), 1, - aux_sym_handler_params_repeat1, - STATE(1439), 1, - sym_handler_params, - [53298] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2186), 1, - sym_identifier, - ACTIONS(2189), 1, anon_sym_in, - STATE(1086), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [53312] = 4, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55192] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2191), 1, + ACTIONS(2186), 4, anon_sym_COMMA, - STATE(1088), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2193), 2, anon_sym_RPAREN, - anon_sym_PIPE, - [53326] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55202] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2191), 1, + ACTIONS(2188), 4, anon_sym_COMMA, - STATE(1063), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2195), 2, anon_sym_RPAREN, - anon_sym_PIPE, - [53340] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55212] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2197), 1, + ACTIONS(2114), 1, sym_identifier, - ACTIONS(2200), 1, + ACTIONS(2190), 1, anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53354] = 4, + STATE(1088), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55226] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2192), 1, sym_identifier, - ACTIONS(2202), 1, + ACTIONS(2195), 1, anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53368] = 2, + STATE(1088), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55240] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2204), 4, + ACTIONS(2197), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [53378] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2206), 1, - anon_sym_COMMA, - STATE(1094), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2208), 2, - anon_sym_GT, - anon_sym_RPAREN, - [53392] = 5, + [55250] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, + ACTIONS(2130), 1, sym_identifier, - ACTIONS(2210), 1, + ACTIONS(2199), 1, anon_sym_RPAREN, - STATE(1116), 1, + STATE(1254), 1, sym_extern_parameter, - STATE(1412), 1, + STATE(1500), 1, sym_extern_parameter_list, - [53408] = 4, + [55266] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2206), 1, + ACTIONS(697), 4, anon_sym_COMMA, - STATE(1066), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2212), 2, - anon_sym_GT, anon_sym_RPAREN, - [53422] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55276] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, - sym_identifier, - ACTIONS(2214), 1, - anon_sym_in, - STATE(1089), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53436] = 2, + ACTIONS(2201), 1, + anon_sym_COLON_COLON, + STATE(1075), 1, + aux_sym_import_target_repeat1, + ACTIONS(2204), 2, + sym__statement_break, + anon_sym_as, + [55290] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2216), 4, + ACTIONS(2206), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [53446] = 2, + [55300] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2218), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [53456] = 2, + ACTIONS(2114), 1, + sym_identifier, + ACTIONS(2208), 1, + anon_sym_in, + STATE(1088), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55314] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2220), 4, + ACTIONS(2210), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [53466] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2182), 1, - sym_identifier, - ACTIONS(2222), 1, - anon_sym_EQ_GT, - STATE(1179), 1, - aux_sym_handler_params_repeat1, - STATE(1424), 1, - sym_handler_params, - [53482] = 2, + [55324] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1791), 4, - anon_sym_LBRACE, + ACTIONS(2212), 4, anon_sym_COMMA, - anon_sym_EQ, + anon_sym_RPAREN, anon_sym_RBRACK, - [53492] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2161), 1, - anon_sym_PIPE, - STATE(1074), 1, - aux_sym_union_type_repeat1, - ACTIONS(1330), 2, - sym__statement_break, - anon_sym_where, - [53506] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2224), 1, - anon_sym_LBRACE, - ACTIONS(2226), 1, - anon_sym_if, - STATE(345), 1, - sym_if_expression, - [53519] = 4, + anon_sym_EQ_GT, + [55334] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(2130), 1, sym_identifier, - STATE(1177), 1, - sym_field_assignment, - STATE(1630), 1, - sym_field_assignments, - [53532] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2230), 1, - anon_sym_COMMA, - ACTIONS(2233), 1, + ACTIONS(2214), 1, anon_sym_RPAREN, - STATE(1104), 1, - aux_sym_pattern_repeat1, - [53545] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2235), 1, - anon_sym_LBRACE, - ACTIONS(2237), 1, - anon_sym_COLON, - STATE(1706), 1, - sym_signature_ascription, - [53558] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(957), 1, - anon_sym_COMMA, - ACTIONS(1736), 1, - anon_sym_RBRACE, - STATE(1243), 1, - aux_sym_field_pattern_repeat1, - [53571] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2239), 1, - anon_sym_as, - ACTIONS(2241), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [53582] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2243), 1, - anon_sym_RBRACE, - ACTIONS(2245), 1, - anon_sym_COMMA, - STATE(1160), 1, - aux_sym_import_member_list_repeat1, - [53595] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2247), 1, - anon_sym_COMMA, - ACTIONS(2249), 1, - anon_sym_GT, - STATE(1161), 1, - aux_sym_type_parameter_list_repeat1, - [53608] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2251), 1, - anon_sym_EQ, - STATE(1389), 1, - sym_block, - [53621] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1997), 1, - anon_sym_DOT, - ACTIONS(2253), 1, - sym__statement_break, - STATE(1125), 1, - aux_sym_legacy_import_path_repeat1, - [53634] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2255), 1, - anon_sym_EQ, - STATE(1388), 1, - sym_block, - [53647] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2257), 1, - anon_sym_EQ, - STATE(1409), 1, - sym_block, - [53660] = 4, + STATE(1254), 1, + sym_extern_parameter, + STATE(1368), 1, + sym_extern_parameter_list, + [55350] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2065), 1, + ACTIONS(2118), 1, sym_identifier, - STATE(965), 1, - sym_qualified_path, - STATE(1294), 1, - sym_effect_ref, - [53673] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2259), 1, - anon_sym_COMMA, - ACTIONS(2261), 1, - anon_sym_RBRACK, - STATE(1129), 1, - aux_sym_effect_list_repeat1, - [53686] = 4, + ACTIONS(2216), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55364] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2263), 1, + ACTIONS(2218), 4, anon_sym_COMMA, - ACTIONS(2265), 1, anon_sym_RPAREN, - STATE(1167), 1, - aux_sym_extern_parameter_list_repeat1, - [53699] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2267), 1, - anon_sym_EQ, - STATE(1429), 1, - sym_block, - [53712] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2269), 1, - anon_sym_RBRACE, - ACTIONS(2271), 1, - anon_sym_COMMA, - STATE(1170), 1, - aux_sym_field_declarations_repeat1, - [53725] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55374] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2273), 1, + ACTIONS(2118), 1, sym_identifier, - STATE(1118), 1, - sym_field_declaration, - STATE(1411), 1, - sym_field_declarations, - [53738] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2275), 1, - anon_sym_LBRACE, - ACTIONS(2277), 1, - anon_sym_SEMI, - STATE(1722), 1, - sym_namespace_body, - [53751] = 4, + ACTIONS(2220), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55388] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2279), 1, + ACTIONS(2118), 1, sym_identifier, - STATE(1010), 1, - sym_qualified_path, - STATE(1176), 1, - sym_variant, - [53764] = 4, + ACTIONS(2222), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55402] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2281), 1, - anon_sym_EQ, - STATE(1463), 1, - sym_block, - [53777] = 4, + ACTIONS(2118), 1, + sym_identifier, + ACTIONS(2224), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55416] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, - anon_sym_COLON, - ACTIONS(2283), 1, - anon_sym_LBRACE, - STATE(1486), 1, - sym_signature_ascription, - [53790] = 4, + ACTIONS(2226), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55426] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1334), 1, - sym__statement_break, - ACTIONS(2285), 1, - anon_sym_where, - STATE(1473), 1, - sym_type_validation, - [53803] = 4, + ACTIONS(2228), 1, + anon_sym_COMMA, + STATE(1083), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2230), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [55440] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2287), 1, - anon_sym_DOT, - ACTIONS(2290), 1, - sym__statement_break, - STATE(1125), 1, - aux_sym_legacy_import_path_repeat1, - [53816] = 2, + ACTIONS(2098), 1, + anon_sym_COMMA, + STATE(1058), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2232), 2, + anon_sym_GT, + anon_sym_RPAREN, + [55454] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2292), 3, + ACTIONS(1780), 1, + anon_sym_LT, + ACTIONS(1784), 1, + anon_sym_LBRACK, + ACTIONS(982), 2, sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [53825] = 4, + anon_sym_where, + [55468] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2294), 1, + ACTIONS(2130), 1, sym_identifier, - ACTIONS(2297), 1, - anon_sym_EQ_GT, - STATE(1127), 1, - aux_sym_handler_params_repeat1, - [53838] = 4, + ACTIONS(2234), 1, + anon_sym_RPAREN, + STATE(1254), 1, + sym_extern_parameter, + STATE(1572), 1, + sym_extern_parameter_list, + [55484] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1799), 4, anon_sym_LBRACE, - ACTIONS(2299), 1, - anon_sym_EQ, - STATE(1516), 1, - sym_block, - [53851] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2301), 1, anon_sym_COMMA, - ACTIONS(2304), 1, + anon_sym_EQ, anon_sym_RBRACK, - STATE(1129), 1, - aux_sym_effect_list_repeat1, - [53864] = 4, + [55494] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2306), 1, - anon_sym_RBRACE, - ACTIONS(2308), 1, - anon_sym_COMMA, - STATE(1130), 1, - aux_sym_field_assignments_repeat1, - [53877] = 4, + ACTIONS(2096), 1, + anon_sym_PIPE, + STATE(1057), 1, + aux_sym_union_type_repeat1, + ACTIONS(1337), 2, + sym__statement_break, + anon_sym_where, + [55508] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2311), 1, - anon_sym_COMMA, - ACTIONS(2313), 1, - anon_sym_RPAREN, - STATE(1200), 1, - aux_sym_tuple_pattern_repeat1, - [53890] = 4, + ACTIONS(2236), 1, + sym_identifier, + STATE(969), 1, + sym_qualified_path, + STATE(1207), 1, + sym_effect_ref, + STATE(1440), 1, + sym_effect_list, + [55524] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2315), 1, + ACTIONS(2236), 1, sym_identifier, - ACTIONS(2317), 1, - sym_static_stage, - STATE(995), 1, + STATE(969), 1, sym_qualified_path, - [53903] = 4, + STATE(1207), 1, + sym_effect_ref, + STATE(1435), 1, + sym_effect_list, + [55540] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2319), 1, + ACTIONS(2238), 4, anon_sym_COMMA, - ACTIONS(2321), 1, + anon_sym_RPAREN, anon_sym_RBRACK, - STATE(1203), 1, - aux_sym_list_pattern_repeat1, - [53916] = 3, + anon_sym_EQ_GT, + [55550] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2323), 1, + ACTIONS(2236), 1, sym_identifier, - STATE(1080), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [53927] = 4, + ACTIONS(2240), 1, + anon_sym_LBRACK, + STATE(969), 1, + sym_qualified_path, + STATE(1292), 1, + sym_effect_ref, + [55566] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2325), 1, + ACTIONS(2118), 1, + sym_identifier, + ACTIONS(2242), 1, + anon_sym_in, + STATE(1084), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [55580] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2244), 4, anon_sym_COMMA, - ACTIONS(2327), 1, anon_sym_RPAREN, - STATE(1204), 1, - aux_sym_pattern_repeat1, - [53940] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55590] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2329), 1, - anon_sym_RBRACE, - ACTIONS(2331), 1, + ACTIONS(2246), 4, anon_sym_COMMA, - STATE(1136), 1, - aux_sym_map_literal_repeat1, - [53953] = 4, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55600] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2334), 1, - anon_sym_EQ, - STATE(1540), 1, - sym_block, - [53966] = 4, + ACTIONS(2228), 1, + anon_sym_COMMA, + STATE(1104), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2248), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [55614] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2250), 1, + anon_sym_COMMA, + ACTIONS(2252), 1, + anon_sym_RPAREN, + STATE(1214), 1, + aux_sym_extern_parameter_list_repeat1, + [55627] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2336), 1, + ACTIONS(1750), 1, anon_sym_RBRACE, - ACTIONS(2338), 1, + ACTIONS(2254), 1, anon_sym_COMMA, - STATE(1130), 1, - aux_sym_field_assignments_repeat1, - [53979] = 4, + STATE(1167), 1, + aux_sym_field_pattern_repeat1, + [55640] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(2257), 1, anon_sym_LBRACE, - ACTIONS(2340), 1, - anon_sym_EQ, - STATE(1556), 1, - sym_block, - [53992] = 4, + ACTIONS(2259), 1, + anon_sym_if, + STATE(487), 1, + sym_if_expression, + [55653] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2342), 1, - anon_sym_EQ, - STATE(1568), 1, - sym_block, - [54005] = 4, + ACTIONS(2261), 1, + sym_identifier, + ACTIONS(2264), 1, + anon_sym_EQ_GT, + STATE(1121), 1, + aux_sym_handler_params_repeat1, + [55666] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2266), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [55675] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2268), 1, + anon_sym_as, + ACTIONS(2270), 2, anon_sym_RBRACE, - ACTIONS(2346), 1, anon_sym_COMMA, - STATE(1136), 1, - aux_sym_map_literal_repeat1, - [54018] = 4, + [55686] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2247), 1, + ACTIONS(931), 1, anon_sym_COMMA, - ACTIONS(2348), 1, - anon_sym_GT, - STATE(1109), 1, - aux_sym_type_parameter_list_repeat1, - [54031] = 4, + ACTIONS(2272), 1, + anon_sym_RBRACE, + STATE(1185), 1, + aux_sym_field_pattern_repeat1, + [55699] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2350), 1, + ACTIONS(2274), 1, anon_sym_EQ, - STATE(1622), 1, + STATE(755), 1, sym_block, - [54044] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2141), 3, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - [54053] = 4, + [55712] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2352), 1, + ACTIONS(2276), 1, anon_sym_EQ, - STATE(1652), 1, + STATE(1649), 1, sym_block, - [54066] = 4, + [55725] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2273), 1, + ACTIONS(2278), 1, sym_identifier, - STATE(1118), 1, - sym_field_declaration, - STATE(1571), 1, - sym_field_declarations, - [54079] = 4, + STATE(644), 1, + sym_qualified_path, + STATE(649), 1, + sym_variant, + [55738] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2280), 1, + anon_sym_EQ, + STATE(1635), 1, + sym_block, + [55751] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1064), 1, + ACTIONS(2094), 3, anon_sym_COMMA, - ACTIONS(2354), 1, + anon_sym_GT, anon_sym_RPAREN, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - [54092] = 4, + [55760] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2356), 1, + ACTIONS(2282), 1, + anon_sym_RBRACE, + ACTIONS(2284), 1, anon_sym_COMMA, - ACTIONS(2358), 1, - anon_sym_RPAREN, - STATE(1210), 1, - aux_sym_named_argument_list_repeat1, - [54105] = 4, + STATE(1181), 1, + aux_sym_field_assignments_repeat1, + [55773] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2360), 1, + ACTIONS(2286), 1, anon_sym_EQ, - STATE(1682), 1, + STATE(1728), 1, sym_block, - [54118] = 4, + [55786] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2362), 1, + ACTIONS(2288), 1, anon_sym_RBRACE, - ACTIONS(2364), 1, + ACTIONS(2290), 1, anon_sym_COMMA, - STATE(1150), 1, - aux_sym_field_pattern_repeat1, - [54131] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1342), 1, - sym__statement_break, - ACTIONS(2285), 1, - anon_sym_where, - STATE(1613), 1, - sym_type_validation, - [54144] = 4, + STATE(1148), 1, + aux_sym_map_literal_repeat1, + [55799] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2346), 1, - anon_sym_COMMA, - ACTIONS(2367), 1, - anon_sym_RBRACE, - STATE(1154), 1, - aux_sym_map_literal_repeat1, - [54157] = 4, + ACTIONS(2292), 1, + sym_identifier, + ACTIONS(2294), 1, + anon_sym_EQ_GT, + STATE(1121), 1, + aux_sym_handler_params_repeat1, + [55812] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1344), 1, + ACTIONS(1345), 1, sym__statement_break, - ACTIONS(2285), 1, + ACTIONS(2296), 1, anon_sym_where, - STATE(1577), 1, + STATE(1739), 1, sym_type_validation, - [54170] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2346), 1, - anon_sym_COMMA, - ACTIONS(2369), 1, - anon_sym_RBRACE, - STATE(1136), 1, - aux_sym_map_literal_repeat1, - [54183] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2371), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_PIPE, - [54192] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(2373), 1, - anon_sym_RBRACK, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - [54205] = 4, + [55825] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2375), 1, + ACTIONS(2298), 1, anon_sym_EQ, - STATE(1719), 1, + STATE(703), 1, sym_block, - [54218] = 2, + [55838] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 3, + ACTIONS(2300), 1, anon_sym_COMMA, + ACTIONS(2303), 1, anon_sym_RPAREN, - anon_sym_PIPE, - [54227] = 2, + STATE(1136), 1, + aux_sym_tuple_pattern_repeat1, + [55851] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1999), 3, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [54236] = 4, + ACTIONS(2305), 1, + anon_sym_LBRACE, + ACTIONS(2307), 1, + anon_sym_if, + STATE(287), 1, + sym_if_expression, + [55864] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2245), 1, - anon_sym_COMMA, - ACTIONS(2377), 1, + ACTIONS(2309), 1, anon_sym_RBRACE, - STATE(1222), 1, - aux_sym_import_member_list_repeat1, - [54249] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2379), 1, + ACTIONS(2311), 1, anon_sym_COMMA, - ACTIONS(2382), 1, - anon_sym_GT, - STATE(1161), 1, - aux_sym_type_parameter_list_repeat1, - [54262] = 4, + STATE(1138), 1, + aux_sym_field_assignments_repeat1, + [55877] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2384), 1, + ACTIONS(2314), 1, anon_sym_EQ, - STATE(734), 1, + STATE(706), 1, sym_block, - [54275] = 4, + [55890] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2386), 1, + ACTIONS(2236), 1, sym_identifier, - STATE(638), 1, + STATE(969), 1, sym_qualified_path, - STATE(646), 1, - sym_variant, - [54288] = 3, + STATE(1359), 1, + sym_effect_ref, + [55903] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1158), 1, - sym_parameter, - ACTIONS(2005), 2, - anon_sym__, - sym_identifier, - [54299] = 4, + ACTIONS(2316), 1, + anon_sym_COMMA, + ACTIONS(2319), 1, + anon_sym_RBRACK, + STATE(1141), 1, + aux_sym_list_pattern_repeat1, + [55916] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2388), 1, - anon_sym_EQ, - STATE(1639), 1, - sym_block, - [54312] = 4, + ACTIONS(2321), 1, + anon_sym_COMMA, + ACTIONS(2323), 1, + anon_sym_RBRACK, + STATE(1172), 1, + aux_sym_effect_list_repeat1, + [55929] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2047), 1, - anon_sym_DOT, - STATE(1566), 1, - sym_type_arguments, - [54325] = 4, + ACTIONS(2325), 1, + anon_sym_RBRACE, + ACTIONS(2327), 1, + anon_sym_COMMA, + STATE(1217), 1, + aux_sym_field_declarations_repeat1, + [55942] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2263), 1, - anon_sym_COMMA, - ACTIONS(2390), 1, - anon_sym_RPAREN, - STATE(1233), 1, - aux_sym_extern_parameter_list_repeat1, - [54338] = 4, + ACTIONS(2329), 1, + anon_sym_LBRACE, + ACTIONS(2331), 1, + anon_sym_COLON, + STATE(1480), 1, + sym_signature_ascription, + [55955] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2392), 1, + ACTIONS(2333), 1, anon_sym_EQ, - STATE(747), 1, + STATE(1664), 1, sym_block, - [54351] = 4, + [55968] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2394), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2396), 1, - anon_sym_if, - STATE(287), 1, - sym_if_expression, - [54364] = 4, + ACTIONS(2335), 1, + anon_sym_EQ, + STATE(713), 1, + sym_block, + [55981] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2337), 1, + anon_sym_COMMA, + ACTIONS(2339), 1, + anon_sym_RPAREN, + STATE(1249), 1, + aux_sym_pattern_repeat1, + [55994] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2271), 1, + ACTIONS(2290), 1, anon_sym_COMMA, - ACTIONS(2398), 1, + ACTIONS(2341), 1, anon_sym_RBRACE, - STATE(1236), 1, - aux_sym_field_declarations_repeat1, - [54377] = 4, + STATE(1149), 1, + aux_sym_map_literal_repeat1, + [56007] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2343), 1, + anon_sym_RBRACE, + ACTIONS(2345), 1, + anon_sym_COMMA, + STATE(1149), 1, + aux_sym_map_literal_repeat1, + [56020] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2400), 1, + ACTIONS(2348), 1, anon_sym_EQ, - STATE(687), 1, + STATE(720), 1, sym_block, - [54390] = 4, + [56033] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1736), 1, - anon_sym_RBRACE, - ACTIONS(2402), 1, + ACTIONS(2350), 1, anon_sym_COMMA, - STATE(1199), 1, - aux_sym_field_pattern_repeat1, - [54403] = 4, + ACTIONS(2352), 1, + anon_sym_RPAREN, + STATE(1136), 1, + aux_sym_tuple_pattern_repeat1, + [56046] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2206), 1, + ACTIONS(2354), 1, + anon_sym_RBRACE, + ACTIONS(2356), 1, anon_sym_COMMA, - ACTIONS(2405), 1, - anon_sym_RPAREN, - STATE(1240), 1, - aux_sym_positional_payload_repeat1, - [54416] = 3, + STATE(1176), 1, + aux_sym_import_member_list_repeat1, + [56059] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2358), 1, + anon_sym_EQ, + STATE(724), 1, + sym_block, + [56072] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, + ACTIONS(1863), 1, sym_identifier, - STATE(1044), 2, + STATE(1080), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54427] = 4, + [56083] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2407), 1, + ACTIONS(2360), 1, anon_sym_EQ, - STATE(686), 1, + STATE(726), 1, sym_block, - [54440] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1321), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [54449] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2338), 1, - anon_sym_COMMA, - ACTIONS(2409), 1, - anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_field_assignments_repeat1, - [54462] = 4, + [56096] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2411), 1, + ACTIONS(2362), 1, anon_sym_EQ, - STATE(691), 1, + STATE(1364), 1, sym_block, - [54475] = 4, + [56109] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2413), 1, - sym_identifier, - ACTIONS(2415), 1, - anon_sym_EQ_GT, - STATE(1127), 1, - aux_sym_handler_params_repeat1, - [54488] = 4, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2364), 1, + anon_sym_EQ, + STATE(729), 1, + sym_block, + [56122] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1064), 1, + ACTIONS(2366), 1, anon_sym_COMMA, - ACTIONS(2417), 1, + ACTIONS(2368), 1, anon_sym_RBRACK, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - [54501] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1915), 1, - anon_sym_LBRACE, - ACTIONS(2419), 1, - anon_sym_EQ, - STATE(694), 1, - sym_block, - [54514] = 4, + STATE(1141), 1, + aux_sym_list_pattern_repeat1, + [56135] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2421), 1, + ACTIONS(2370), 1, anon_sym_LBRACE, - STATE(1621), 1, + STATE(1724), 1, sym_signature_ascription, - [54527] = 4, + [56148] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2423), 1, + ACTIONS(2372), 1, anon_sym_EQ, - STATE(697), 1, + STATE(736), 1, sym_block, - [54540] = 4, + [56161] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2425), 1, + ACTIONS(2374), 1, anon_sym_EQ, - STATE(700), 1, + STATE(737), 1, sym_block, - [54553] = 4, + [56174] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2376), 1, + anon_sym_COMMA, + ACTIONS(2378), 1, + anon_sym_RPAREN, + STATE(1182), 1, + aux_sym_named_argument_list_repeat1, + [56187] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2427), 1, + ACTIONS(2380), 1, anon_sym_EQ, - STATE(705), 1, + STATE(739), 1, sym_block, - [54566] = 4, + [56200] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(2382), 1, + anon_sym_RBRACK, + STATE(1062), 1, + aux_sym_argument_list_repeat1, + [56213] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2429), 1, + ACTIONS(2384), 1, anon_sym_EQ, - STATE(706), 1, + STATE(741), 1, sym_block, - [54579] = 4, + [56226] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(2386), 1, anon_sym_LBRACE, - ACTIONS(2431), 1, - anon_sym_EQ, - STATE(709), 1, - sym_block, - [54592] = 4, + ACTIONS(2388), 1, + anon_sym_SEMI, + STATE(1464), 1, + sym_namespace_body, + [56239] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2272), 1, + anon_sym_RBRACE, + ACTIONS(2390), 1, + anon_sym_COMMA, + STATE(1185), 1, + aux_sym_field_pattern_repeat1, + [56252] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2433), 1, + ACTIONS(2393), 1, anon_sym_EQ, - STATE(710), 1, + STATE(744), 1, sym_block, - [54605] = 4, + [56265] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2435), 1, + ACTIONS(2395), 1, anon_sym_EQ, - STATE(680), 1, + STATE(745), 1, sym_block, - [54618] = 4, + [56278] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2437), 1, + ACTIONS(2397), 1, anon_sym_EQ, - STATE(714), 1, + STATE(746), 1, sym_block, - [54631] = 4, + [56291] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2439), 1, + ACTIONS(2399), 1, anon_sym_EQ, - STATE(716), 1, + STATE(750), 1, sym_block, - [54644] = 4, + [56304] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2401), 1, + anon_sym_COMMA, + ACTIONS(2404), 1, + anon_sym_RBRACK, + STATE(1172), 1, + aux_sym_effect_list_repeat1, + [56317] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2346), 1, + ACTIONS(2290), 1, anon_sym_COMMA, - ACTIONS(2441), 1, + ACTIONS(2406), 1, anon_sym_RBRACE, - STATE(1141), 1, + STATE(1244), 1, + aux_sym_map_literal_repeat1, + [56330] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2290), 1, + anon_sym_COMMA, + ACTIONS(2408), 1, + anon_sym_RBRACE, + STATE(1178), 1, + aux_sym_map_literal_repeat1, + [56343] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2410), 1, + anon_sym_COMMA, + ACTIONS(2412), 1, + anon_sym_RBRACK, + STATE(1158), 1, + aux_sym_list_pattern_repeat1, + [56356] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2356), 1, + anon_sym_COMMA, + ACTIONS(2414), 1, + anon_sym_RBRACE, + STATE(1199), 1, + aux_sym_import_member_list_repeat1, + [56369] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2098), 1, + anon_sym_COMMA, + ACTIONS(2416), 1, + anon_sym_RPAREN, + STATE(1221), 1, + aux_sym_positional_payload_repeat1, + [56382] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2290), 1, + anon_sym_COMMA, + ACTIONS(2418), 1, + anon_sym_RBRACE, + STATE(1149), 1, aux_sym_map_literal_repeat1, - [54657] = 4, + [56395] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2420), 1, + sym_identifier, + ACTIONS(2422), 1, + sym_static_stage, + STATE(1024), 1, + sym_qualified_path, + [56408] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(2424), 1, + anon_sym_RBRACK, + STATE(1062), 1, + aux_sym_argument_list_repeat1, + [56421] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2284), 1, + anon_sym_COMMA, + ACTIONS(2426), 1, + anon_sym_RBRACE, + STATE(1138), 1, + aux_sym_field_assignments_repeat1, + [56434] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2428), 1, + anon_sym_COMMA, + ACTIONS(2431), 1, + anon_sym_RPAREN, + STATE(1182), 1, + aux_sym_named_argument_list_repeat1, + [56447] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2337), 1, + anon_sym_COMMA, + ACTIONS(2433), 1, + anon_sym_RPAREN, + STATE(1147), 1, + aux_sym_pattern_repeat1, + [56460] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1915), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2443), 1, + ACTIONS(2435), 1, anon_sym_EQ, - STATE(718), 1, + STATE(1376), 1, sym_block, - [54670] = 4, + [56473] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2445), 1, + ACTIONS(2437), 1, + anon_sym_RBRACE, + ACTIONS(2439), 1, anon_sym_COMMA, - ACTIONS(2447), 1, - anon_sym_RBRACK, - STATE(1133), 1, - aux_sym_list_pattern_repeat1, - [54683] = 4, + STATE(1185), 1, + aux_sym_field_pattern_repeat1, + [56486] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2449), 1, + ACTIONS(2331), 1, + anon_sym_COLON, + ACTIONS(2442), 1, anon_sym_LBRACE, - ACTIONS(2451), 1, - anon_sym_if, - STATE(498), 1, - sym_if_expression, - [54696] = 3, + STATE(1674), 1, + sym_signature_ascription, + [56499] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, + STATE(1166), 1, + sym_namespace_name, + ACTIONS(2444), 2, + sym_string, sym_identifier, - STATE(1095), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54707] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2346), 1, - anon_sym_COMMA, - ACTIONS(2453), 1, - anon_sym_RBRACE, - STATE(1201), 1, - aux_sym_map_literal_repeat1, - [54720] = 4, + [56510] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2275), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2455), 1, - anon_sym_SEMI, - STATE(1619), 1, - sym_namespace_body, - [54733] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2457), 1, - anon_sym_RBRACE, - ACTIONS(2459), 1, - anon_sym_COMMA, - STATE(1150), 1, - aux_sym_field_pattern_repeat1, - [54746] = 4, + ACTIONS(2446), 1, + anon_sym_EQ, + STATE(1520), 1, + sym_block, + [56523] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2462), 1, - anon_sym_COMMA, - ACTIONS(2465), 1, - anon_sym_RPAREN, - STATE(1200), 1, - aux_sym_tuple_pattern_repeat1, - [54759] = 4, + ACTIONS(2448), 1, + sym_identifier, + STATE(1130), 1, + sym_field_assignment, + STATE(1370), 1, + sym_field_assignments, + [56536] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2346), 1, - anon_sym_COMMA, - ACTIONS(2467), 1, - anon_sym_RBRACE, - STATE(1136), 1, - aux_sym_map_literal_repeat1, - [54772] = 4, + ACTIONS(2450), 1, + anon_sym_LBRACE, + ACTIONS(2452), 1, + anon_sym_if, + STATE(380), 1, + sym_if_expression, + [56549] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1064), 1, - anon_sym_COMMA, - ACTIONS(2469), 1, - anon_sym_RBRACK, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - [54785] = 4, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2454), 1, + anon_sym_EQ, + STATE(1389), 1, + sym_block, + [56562] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2471), 1, - anon_sym_COMMA, - ACTIONS(2474), 1, - anon_sym_RBRACK, - STATE(1203), 1, - aux_sym_list_pattern_repeat1, - [54798] = 4, + STATE(1250), 1, + sym_parameter, + ACTIONS(2009), 2, + anon_sym__, + sym_identifier, + [56573] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2325), 1, - anon_sym_COMMA, - ACTIONS(2476), 1, - anon_sym_RPAREN, - STATE(1104), 1, - aux_sym_pattern_repeat1, - [54811] = 3, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2456), 1, + anon_sym_EQ, + STATE(1397), 1, + sym_block, + [56586] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2323), 1, + ACTIONS(2458), 1, sym_identifier, - STATE(1079), 2, + STATE(1063), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [54822] = 3, + [56597] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1198), 1, - sym_namespace_name, - ACTIONS(2478), 2, - sym_string, - sym_identifier, - [54833] = 4, + ACTIONS(2460), 1, + anon_sym_COMMA, + ACTIONS(2462), 1, + anon_sym_GT, + STATE(1226), 1, + aux_sym_type_parameter_list_repeat1, + [56610] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2480), 1, + ACTIONS(2464), 1, anon_sym_LBRACE, - STATE(1724), 1, + STATE(1577), 1, sym_signature_ascription, - [54846] = 4, + [56623] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(2448), 1, sym_identifier, - STATE(1177), 1, + STATE(1130), 1, sym_field_assignment, - STATE(1708), 1, + STATE(1747), 1, sym_field_assignments, - [54859] = 4, + [56636] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(2466), 1, + anon_sym_COMMA, + ACTIONS(2469), 1, + anon_sym_GT, + STATE(1198), 1, + aux_sym_type_parameter_list_repeat1, + [56649] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2471), 1, + anon_sym_RBRACE, + ACTIONS(2473), 1, + anon_sym_COMMA, + STATE(1199), 1, + aux_sym_import_member_list_repeat1, + [56662] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2448), 1, sym_identifier, - STATE(1177), 1, + STATE(1130), 1, sym_field_assignment, - STATE(1721), 1, + STATE(1363), 1, sym_field_assignments, - [54872] = 4, + [56675] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2482), 1, - anon_sym_COMMA, - ACTIONS(2485), 1, - anon_sym_RPAREN, - STATE(1210), 1, - aux_sym_named_argument_list_repeat1, - [54885] = 3, + ACTIONS(2476), 1, + sym_identifier, + STATE(1255), 1, + sym_field_declaration, + STATE(1585), 1, + sym_field_declarations, + [56688] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, + ACTIONS(1863), 1, sym_identifier, - STATE(1040), 2, + STATE(1071), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54896] = 4, + [56699] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2487), 1, + ACTIONS(2478), 1, anon_sym_LBRACE, - STATE(1565), 1, + STATE(1590), 1, sym_signature_ascription, - [54909] = 4, + [56712] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2480), 1, + anon_sym_EQ, + STATE(1563), 1, + sym_block, + [56725] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2448), 1, sym_identifier, - STATE(1177), 1, + STATE(1130), 1, sym_field_assignment, - STATE(1361), 1, + STATE(1380), 1, sym_field_assignments, - [54922] = 4, + [56738] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2489), 1, + ACTIONS(2482), 1, anon_sym_LBRACE, - STATE(1575), 1, + STATE(1600), 1, sym_signature_ascription, - [54935] = 4, + [56751] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2273), 1, + ACTIONS(2321), 1, + anon_sym_COMMA, + ACTIONS(2484), 1, + anon_sym_RBRACK, + STATE(1142), 1, + aux_sym_effect_list_repeat1, + [56764] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2476), 1, sym_identifier, - STATE(1118), 1, + STATE(1255), 1, sym_field_declaration, - STATE(1372), 1, + STATE(1392), 1, sym_field_declarations, - [54948] = 3, + [56777] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, + ACTIONS(1863), 1, sym_identifier, - STATE(1075), 2, + STATE(1076), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54959] = 4, + [56788] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2491), 1, - anon_sym_EQ, - STATE(1394), 1, - sym_block, - [54972] = 4, + ACTIONS(1360), 1, + sym__statement_break, + ACTIONS(2296), 1, + anon_sym_where, + STATE(1598), 1, + sym_type_validation, + [56801] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2493), 1, + ACTIONS(2486), 1, anon_sym_LBRACE, - STATE(1587), 1, + STATE(1612), 1, sym_signature_ascription, - [54985] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2273), 1, - sym_identifier, - STATE(1118), 1, - sym_field_declaration, - STATE(1401), 1, - sym_field_declarations, - [54998] = 4, + [56814] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2331), 1, anon_sym_COLON, - ACTIONS(2495), 1, + ACTIONS(2488), 1, anon_sym_LBRACE, - STATE(1508), 1, + STATE(1501), 1, sym_signature_ascription, - [55011] = 3, + [56827] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2323), 1, + ACTIONS(2476), 1, sym_identifier, - STATE(1060), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55022] = 4, + STATE(1255), 1, + sym_field_declaration, + STATE(1421), 1, + sym_field_declarations, + [56840] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2490), 1, + anon_sym_COMMA, + ACTIONS(2493), 1, + anon_sym_RPAREN, + STATE(1214), 1, + aux_sym_extern_parameter_list_repeat1, + [56853] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2497), 1, + anon_sym_where, + ACTIONS(2495), 2, anon_sym_RBRACE, - ACTIONS(2499), 1, anon_sym_COMMA, - STATE(1222), 1, - aux_sym_import_member_list_repeat1, - [55035] = 4, + [56864] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - sym_identifier, - STATE(1177), 1, - sym_field_assignment, - STATE(1484), 1, - sym_field_assignments, - [55048] = 4, + ACTIONS(1021), 1, + anon_sym_COMMA, + ACTIONS(2499), 1, + anon_sym_RPAREN, + STATE(1062), 1, + aux_sym_argument_list_repeat1, + [56877] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - sym_identifier, - STATE(1177), 1, - sym_field_assignment, - STATE(1488), 1, - sym_field_assignments, - [55061] = 4, + ACTIONS(2501), 1, + anon_sym_RBRACE, + ACTIONS(2503), 1, + anon_sym_COMMA, + STATE(1217), 1, + aux_sym_field_declarations_repeat1, + [56890] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_LBRACE, - ACTIONS(2502), 1, - anon_sym_EQ, - STATE(1480), 1, - sym_block, - [55074] = 3, + ACTIONS(1358), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56899] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, - sym_identifier, - STATE(1049), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55085] = 4, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2065), 1, + anon_sym_DOT, + STATE(1648), 1, + sym_type_arguments, + [56912] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - sym_identifier, - STATE(1177), 1, - sym_field_assignment, - STATE(1494), 1, - sym_field_assignments, - [55098] = 3, + ACTIONS(1343), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56921] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1831), 1, - sym_identifier, - STATE(1050), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55109] = 4, + ACTIONS(2098), 1, + anon_sym_COMMA, + ACTIONS(2506), 1, + anon_sym_RPAREN, + STATE(1056), 1, + aux_sym_positional_payload_repeat1, + [56934] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2259), 1, - anon_sym_COMMA, - ACTIONS(2504), 1, - anon_sym_RBRACK, - STATE(1115), 1, - aux_sym_effect_list_repeat1, - [55122] = 4, + ACTIONS(1351), 1, + sym__statement_break, + ACTIONS(2296), 1, + anon_sym_where, + STATE(1579), 1, + sym_type_validation, + [56947] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(2448), 1, sym_identifier, - STATE(1177), 1, + STATE(1130), 1, sym_field_assignment, - STATE(1452), 1, + STATE(1424), 1, sym_field_assignments, - [55135] = 3, + [56960] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2067), 1, + anon_sym_DOT, + ACTIONS(2508), 1, + sym__statement_break, + STATE(1241), 1, + aux_sym_legacy_import_path_repeat1, + [56973] = 3, ACTIONS(298), 1, sym_line_comment, - STATE(1120), 1, + STATE(1228), 1, sym_namespace_name, - ACTIONS(2478), 2, + ACTIONS(2444), 2, sym_string, sym_identifier, - [55146] = 4, + [56984] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2506), 1, + ACTIONS(2460), 1, + anon_sym_COMMA, + ACTIONS(2510), 1, + anon_sym_GT, + STATE(1198), 1, + aux_sym_type_parameter_list_repeat1, + [56997] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2458), 1, sym_identifier, - ACTIONS(2508), 1, - sym_static_stage, - STATE(994), 1, - sym_qualified_path, - [55159] = 4, + STATE(1094), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [57008] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2510), 1, - anon_sym_COMMA, - ACTIONS(2513), 1, - anon_sym_RPAREN, - STATE(1233), 1, - aux_sym_extern_parameter_list_repeat1, - [55172] = 3, + ACTIONS(2386), 1, + anon_sym_LBRACE, + ACTIONS(2512), 1, + anon_sym_SEMI, + STATE(1651), 1, + sym_namespace_body, + [57021] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2514), 1, + anon_sym_EQ, + STATE(1450), 1, + sym_block, + [57034] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2517), 1, + ACTIONS(1332), 3, + sym__statement_break, + anon_sym_PIPE, anon_sym_where, - ACTIONS(2515), 2, - anon_sym_RBRACE, + [57043] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1021), 1, anon_sym_COMMA, - [55183] = 4, + ACTIONS(2516), 1, + anon_sym_RBRACK, + STATE(1062), 1, + aux_sym_argument_list_repeat1, + [57056] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2518), 1, + anon_sym_EQ, + STATE(1420), 1, + sym_block, + [57069] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2519), 1, + ACTIONS(2448), 1, sym_identifier, - ACTIONS(2521), 1, - sym_static_stage, - STATE(1013), 1, - sym_qualified_path, - [55196] = 4, + STATE(1130), 1, + sym_field_assignment, + STATE(1504), 1, + sym_field_assignments, + [57082] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2523), 1, - anon_sym_RBRACE, - ACTIONS(2525), 1, - anon_sym_COMMA, - STATE(1236), 1, - aux_sym_field_declarations_repeat1, - [55209] = 2, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2520), 1, + anon_sym_EQ, + STATE(1536), 1, + sym_block, + [57095] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1332), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [55218] = 2, + ACTIONS(2448), 1, + sym_identifier, + STATE(1130), 1, + sym_field_assignment, + STATE(1509), 1, + sym_field_assignments, + [57108] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1863), 1, + sym_identifier, + STATE(1101), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [57119] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1338), 3, + ACTIONS(2069), 3, sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [55227] = 4, + anon_sym_COLON_COLON, + anon_sym_as, + [57128] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2057), 1, - anon_sym_DOT, - STATE(1699), 1, - sym_type_arguments, - [55240] = 4, + ACTIONS(2448), 1, + sym_identifier, + STATE(1130), 1, + sym_field_assignment, + STATE(1515), 1, + sym_field_assignments, + [57141] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2206), 1, + ACTIONS(1863), 1, + sym_identifier, + STATE(1102), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [57152] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2376), 1, anon_sym_COMMA, - ACTIONS(2528), 1, + ACTIONS(2522), 1, anon_sym_RPAREN, - STATE(1066), 1, - aux_sym_positional_payload_repeat1, - [55253] = 4, + STATE(1162), 1, + aux_sym_named_argument_list_repeat1, + [57165] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1340), 1, + ACTIONS(2524), 1, + anon_sym_DOT, + ACTIONS(2527), 1, sym__statement_break, - ACTIONS(2285), 1, - anon_sym_where, - STATE(1573), 1, - sym_type_validation, - [55266] = 4, + STATE(1241), 1, + aux_sym_legacy_import_path_repeat1, + [57178] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2356), 1, + ACTIONS(2529), 3, anon_sym_COMMA, - ACTIONS(2530), 1, anon_sym_RPAREN, - STATE(1148), 1, - aux_sym_named_argument_list_repeat1, - [55279] = 4, + anon_sym_PIPE, + [57187] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(957), 1, + ACTIONS(2458), 1, + sym_identifier, + STATE(1087), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [57198] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2290), 1, anon_sym_COMMA, - ACTIONS(2457), 1, + ACTIONS(2531), 1, anon_sym_RBRACE, - STATE(1150), 1, - aux_sym_field_pattern_repeat1, - [55292] = 4, + STATE(1149), 1, + aux_sym_map_literal_repeat1, + [57211] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 1, - anon_sym_LT, - ACTIONS(2059), 1, - anon_sym_DOT, - STATE(1710), 1, - sym_type_arguments, - [55305] = 4, + ACTIONS(2533), 1, + sym_identifier, + ACTIONS(2535), 1, + sym_static_stage, + STATE(1039), 1, + sym_qualified_path, + [57224] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - sym_identifier, - STATE(1177), 1, - sym_field_assignment, - STATE(1709), 1, - sym_field_assignments, - [55318] = 2, + ACTIONS(1929), 1, + anon_sym_LBRACE, + ACTIONS(2537), 1, + anon_sym_EQ, + STATE(1429), 1, + sym_block, + [57237] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1166), 2, - sym__statement_break, - anon_sym_where, - [55326] = 3, + ACTIONS(931), 1, + anon_sym_COMMA, + ACTIONS(1750), 1, + anon_sym_RBRACE, + STATE(1124), 1, + aux_sym_field_pattern_repeat1, + [57250] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, + ACTIONS(2539), 1, sym_identifier, - STATE(1123), 1, - sym_symbol_path, - [55336] = 3, + ACTIONS(2541), 1, + sym_static_stage, + STATE(1021), 1, + sym_qualified_path, + [57263] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2111), 1, - sym_identifier, - STATE(1301), 1, - sym_import_member, - [55346] = 3, + ACTIONS(2543), 1, + anon_sym_COMMA, + ACTIONS(2546), 1, + anon_sym_RPAREN, + STATE(1249), 1, + aux_sym_pattern_repeat1, + [57276] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2534), 1, - sym_identifier, - STATE(1447), 1, - sym_field_pattern, - [55356] = 2, + ACTIONS(2179), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_PIPE, + [57285] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 2, + ACTIONS(1349), 1, sym__statement_break, + ACTIONS(2296), 1, + anon_sym_where, + STATE(1388), 1, + sym_type_validation, + [57298] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2081), 1, anon_sym_DOT, - [55364] = 2, + STATE(1725), 1, + sym_type_arguments, + [57311] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1999), 2, + ACTIONS(1929), 1, anon_sym_LBRACE, - anon_sym_SEMI, - [55372] = 2, + ACTIONS(2548), 1, + anon_sym_EQ, + STATE(1446), 1, + sym_block, + [57324] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2382), 2, + ACTIONS(2250), 1, anon_sym_COMMA, - anon_sym_GT, - [55380] = 2, + ACTIONS(2550), 1, + anon_sym_RPAREN, + STATE(1118), 1, + aux_sym_extern_parameter_list_repeat1, + [57337] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2536), 2, + ACTIONS(2327), 1, anon_sym_COMMA, - anon_sym_RPAREN, - [55388] = 3, + ACTIONS(2552), 1, + anon_sym_RBRACE, + STATE(1143), 1, + aux_sym_field_declarations_repeat1, + [57350] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2538), 1, - anon_sym_COLON, - ACTIONS(2540), 1, - anon_sym_EQ, - [55398] = 2, + ACTIONS(2476), 1, + sym_identifier, + STATE(1255), 1, + sym_field_declaration, + STATE(1573), 1, + sym_field_declarations, + [57363] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2233), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [55406] = 3, + ACTIONS(2554), 1, + sym_identifier, + STATE(1005), 1, + sym_qualified_path, + STATE(1230), 1, + sym_variant, + [57376] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1829), 1, + anon_sym_LT2, + ACTIONS(2085), 1, + anon_sym_DOT, + STATE(1736), 1, + sym_type_arguments, + [57389] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2542), 1, + ACTIONS(1929), 1, anon_sym_LBRACE, - ACTIONS(2544), 1, - anon_sym_LT, - [55416] = 3, + ACTIONS(2556), 1, + anon_sym_EQ, + STATE(1437), 1, + sym_block, + [57402] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2546), 1, - anon_sym_DASH_GT, - ACTIONS(2548), 1, - anon_sym_EQ_GT, - [55426] = 3, + ACTIONS(2448), 1, + sym_identifier, + STATE(1130), 1, + sym_field_assignment, + STATE(1513), 1, + sym_field_assignments, + [57415] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1370), 1, - sym__statement_break, - ACTIONS(2550), 1, - anon_sym_DASH_GT, - [55436] = 2, + ACTIONS(1863), 1, + sym_identifier, + STATE(1065), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [57426] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2552), 2, - anon_sym_COMMA, - anon_sym_RBRACK, - [55444] = 3, + ACTIONS(2558), 1, + anon_sym_LBRACE, + ACTIONS(2560), 1, + anon_sym_LT, + [57436] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2554), 1, + ACTIONS(2562), 1, sym_identifier, - STATE(1330), 1, + STATE(1459), 1, sym_field_pattern, - [55454] = 2, + [57446] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2556), 2, - anon_sym__, - sym_identifier, - [55462] = 3, + ACTIONS(1402), 2, + sym__statement_break, + anon_sym_where, + [57454] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2558), 1, + ACTIONS(2564), 1, sym_identifier, - STATE(1166), 1, + STATE(1051), 1, sym_qualified_path, - [55472] = 2, + [57464] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1779), 2, - anon_sym_LBRACE, - anon_sym_EQ, - [55480] = 3, + ACTIONS(2566), 1, + anon_sym_DASH_GT, + ACTIONS(2568), 1, + anon_sym_EQ_GT, + [57474] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2560), 1, + ACTIONS(2570), 1, sym_float, - ACTIONS(2562), 1, + ACTIONS(2572), 1, sym_integer, - [55490] = 3, + [57484] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2564), 1, - anon_sym_DASH_GT, - ACTIONS(2566), 1, - anon_sym_EQ_GT, - [55500] = 3, + ACTIONS(1270), 2, + sym__statement_break, + anon_sym_where, + [57492] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2574), 1, + anon_sym_LBRACE, + ACTIONS(2576), 1, + anon_sym_STAR, + [57502] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2534), 1, + ACTIONS(2578), 1, sym_identifier, - STATE(1489), 1, + STATE(1334), 1, sym_field_pattern, - [55510] = 3, + [57512] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1724), 1, - anon_sym_LBRACE, - ACTIONS(1730), 1, + ACTIONS(2580), 1, + sym_identifier, + ACTIONS(2582), 1, anon_sym_LPAREN, - [55520] = 3, + [57522] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2568), 1, - sym_identifier, - ACTIONS(2570), 1, - anon_sym_LPAREN, - [55530] = 3, + ACTIONS(2584), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57530] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2572), 1, - anon_sym_LT, - ACTIONS(2574), 1, - anon_sym_LPAREN, - [55540] = 3, + ACTIONS(2586), 1, + anon_sym_LBRACE, + ACTIONS(2588), 1, + anon_sym_LT, + [57540] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2576), 1, + ACTIONS(2590), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + [57548] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1414), 1, + sym__statement_break, + ACTIONS(2592), 1, anon_sym_DASH_GT, - ACTIONS(2578), 1, - anon_sym_EQ_GT, - [55550] = 3, + [57558] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2580), 1, - anon_sym_EQ, - ACTIONS(2582), 1, - anon_sym_LT, - [55560] = 3, + ACTIONS(2493), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57566] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2584), 1, - anon_sym_LBRACE, - ACTIONS(2586), 1, - anon_sym_LT, - [55570] = 3, + ACTIONS(2431), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57574] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1742), 1, - anon_sym_LBRACE, - ACTIONS(2588), 1, - anon_sym_PLUS, - [55580] = 3, + ACTIONS(2343), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57582] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, - sym_identifier, - STATE(1182), 1, - sym_symbol_path, - [55590] = 2, + ACTIONS(2437), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57590] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2590), 2, + ACTIONS(2501), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_GT, - [55598] = 3, + [57598] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2592), 1, - anon_sym_LBRACE, - ACTIONS(2594), 1, - anon_sym_LT, - [55608] = 3, + ACTIONS(2594), 2, + anon_sym__, + sym_identifier, + [57606] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, + ACTIONS(2562), 1, sym_identifier, - STATE(1283), 1, - sym_symbol_path, - [55618] = 3, + STATE(1745), 1, + sym_field_pattern, + [57616] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2596), 1, anon_sym_LT, ACTIONS(2598), 1, anon_sym_LPAREN, - [55628] = 2, + [57626] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2485), 2, + ACTIONS(2309), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_RPAREN, - [55636] = 3, + [57634] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2582), 1, + anon_sym_LPAREN, ACTIONS(2600), 1, - anon_sym_LBRACE, + sym_identifier, + [57644] = 3, + ACTIONS(298), 1, + sym_line_comment, ACTIONS(2602), 1, + anon_sym_DASH_GT, + ACTIONS(2604), 1, + anon_sym_EQ_GT, + [57654] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2606), 1, + anon_sym_EQ, + ACTIONS(2608), 1, anon_sym_LT, - [55646] = 3, + [57664] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1238), 2, sym__statement_break, - ACTIONS(2604), 1, - anon_sym_DASH_GT, - [55656] = 3, + anon_sym_where, + [57672] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2105), 1, - sym_identifier, - STATE(1323), 1, - sym_extern_parameter, - [55666] = 3, + ACTIONS(2610), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57680] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2606), 1, - anon_sym_COLON, - STATE(826), 1, - sym_signature_ascription, - [55676] = 3, + ACTIONS(2612), 1, + sym_identifier, + STATE(1159), 1, + sym_symbol_path, + [57690] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2608), 1, - anon_sym_LBRACE, - ACTIONS(2610), 1, - anon_sym_STAR, - [55686] = 3, + ACTIONS(2448), 1, + sym_identifier, + STATE(1284), 1, + sym_field_assignment, + [57700] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(1805), 2, anon_sym_LBRACE, - ACTIONS(2614), 1, - anon_sym_LT, - [55696] = 3, + anon_sym_EQ, + [57708] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2616), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(822), 1, + STATE(1317), 1, sym_symbol_path, - [55706] = 2, + [57718] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1128), 2, - sym__statement_break, - anon_sym_where, - [55714] = 2, + ACTIONS(2614), 2, + anon_sym__, + sym_identifier, + [57726] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1400), 2, + ACTIONS(1260), 2, sym__statement_break, anon_sym_where, - [55722] = 3, + [57734] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1680), 1, - sym_static_stage, - ACTIONS(1682), 1, - anon_sym_effect, - [55732] = 3, + ACTIONS(1819), 2, + anon_sym_LBRACE, + anon_sym_EQ, + [57742] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2273), 1, - sym_identifier, - STATE(1328), 1, - sym_field_declaration, - [55742] = 3, + ACTIONS(2616), 1, + anon_sym_LBRACE, + ACTIONS(2618), 1, + anon_sym_LT, + [57752] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1392), 1, + ACTIONS(1406), 1, sym__statement_break, - ACTIONS(2618), 1, + ACTIONS(2620), 1, anon_sym_DASH_GT, - [55752] = 3, + [57762] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2620), 1, - anon_sym_LBRACE, ACTIONS(2622), 1, + anon_sym_LBRACE, + ACTIONS(2624), 1, anon_sym_LT, - [55762] = 3, + [57772] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2624), 1, + ACTIONS(2562), 1, sym_identifier, - STATE(1037), 1, - sym_qualified_path, - [55772] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2304), 2, - anon_sym_COMMA, - anon_sym_RBRACK, - [55780] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1158), 2, - sym__statement_break, - anon_sym_where, - [55788] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1162), 2, - sym__statement_break, - anon_sym_where, - [55796] = 3, + STATE(1665), 1, + sym_field_pattern, + [57782] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2626), 1, - anon_sym_EQ, + anon_sym_COLON, ACTIONS(2628), 1, - anon_sym_LT, - [55806] = 3, + anon_sym_EQ, + [57792] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2630), 1, anon_sym_DASH_GT, ACTIONS(2632), 1, anon_sym_EQ_GT, - [55816] = 3, + [57802] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2634), 1, anon_sym_LBRACE, ACTIONS(2636), 1, anon_sym_LT, - [55826] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2638), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [55834] = 2, + [57812] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2497), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [55842] = 2, + ACTIONS(2476), 1, + sym_identifier, + STATE(1280), 1, + sym_field_declaration, + [57822] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2306), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [55850] = 3, + ACTIONS(1388), 1, + sym__statement_break, + ACTIONS(2638), 1, + anon_sym_DASH_GT, + [57832] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2640), 1, - anon_sym_EQ, + anon_sym_LBRACE, ACTIONS(2642), 1, anon_sym_LT, - [55860] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2532), 1, - sym_identifier, - STATE(1273), 1, - sym_symbol_path, - [55870] = 3, + [57842] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2644), 1, - sym_identifier, - STATE(1279), 1, - sym_named_argument, - [55880] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1366), 1, - sym__statement_break, - ACTIONS(2646), 1, anon_sym_DASH_GT, - [55890] = 3, + ACTIONS(2646), 1, + anon_sym_EQ_GT, + [57852] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, - sym_identifier, - STATE(1220), 1, - sym_symbol_path, - [55900] = 2, + ACTIONS(2648), 1, + anon_sym_COLON, + ACTIONS(2650), 1, + anon_sym_EQ, + [57862] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2648), 2, - anon_sym__, - sym_identifier, - [55908] = 2, + ACTIONS(2527), 2, + sym__statement_break, + anon_sym_DOT, + [57870] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2362), 2, - anon_sym_RBRACE, + ACTIONS(2652), 2, anon_sym_COMMA, - [55916] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2650), 1, - anon_sym_COLON, - ACTIONS(2652), 1, - anon_sym_EQ, - [55926] = 3, + anon_sym_GT, + [57878] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2654), 1, - anon_sym_LT, + anon_sym_EQ, ACTIONS(2656), 1, - anon_sym_LPAREN, - [55936] = 2, + anon_sym_LT, + [57888] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1352), 2, + ACTIONS(1376), 2, sym__statement_break, anon_sym_where, - [55944] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2329), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [55952] = 3, + [57896] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2658), 1, - anon_sym_COLON, - ACTIONS(2660), 1, - anon_sym_EQ, - [55962] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2532), 1, sym_identifier, - STATE(1207), 1, - sym_symbol_path, - [55972] = 3, + STATE(1219), 1, + sym_qualified_path, + [57906] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2660), 1, + anon_sym_LBRACE, ACTIONS(2662), 1, anon_sym_LT, - ACTIONS(2664), 1, - anon_sym_LPAREN, - [55982] = 3, + [57916] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2666), 1, - sym_identifier, - STATE(999), 1, - sym_qualified_path, - [55992] = 3, + ACTIONS(2664), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57924] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1212), 1, + STATE(1186), 1, sym_symbol_path, - [56002] = 3, + [57934] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, - sym_identifier, - STATE(1214), 1, - sym_symbol_path, - [56012] = 2, + ACTIONS(1758), 1, + anon_sym_LBRACE, + ACTIONS(2666), 1, + anon_sym_PLUS, + [57944] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2668), 2, + ACTIONS(2471), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_RPAREN, - [56020] = 3, + [57952] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2668), 1, + anon_sym_COLON, ACTIONS(2670), 1, - anon_sym_LT, - ACTIONS(2672), 1, - anon_sym_LPAREN, - [56030] = 3, + anon_sym_EQ, + [57962] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1218), 1, + STATE(1196), 1, sym_symbol_path, - [56040] = 2, + [57972] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2513), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [56048] = 3, + ACTIONS(2672), 1, + anon_sym_LT, + ACTIONS(2674), 1, + anon_sym_LPAREN, + [57982] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2674), 1, - anon_sym_EQ, ACTIONS(2676), 1, - anon_sym_LT, - [56058] = 3, + sym_identifier, + STATE(995), 1, + sym_qualified_path, + [57992] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2534), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1711), 1, - sym_field_pattern, - [56068] = 3, + STATE(1203), 1, + sym_symbol_path, + [58002] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2534), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1483), 1, - sym_field_pattern, - [56078] = 3, + STATE(1206), 1, + sym_symbol_path, + [58012] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2678), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1017), 1, - sym_qualified_path, - [56088] = 2, + STATE(1212), 1, + sym_symbol_path, + [58022] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2523), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [56096] = 3, + ACTIONS(2612), 1, + sym_identifier, + STATE(1350), 1, + sym_symbol_path, + [58032] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2678), 1, + anon_sym_LT, ACTIONS(2680), 1, - anon_sym_DASH_GT, - ACTIONS(2682), 1, - anon_sym_EQ_GT, - [56106] = 3, + anon_sym_LPAREN, + [58042] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2684), 1, - anon_sym_RBRACE, - ACTIONS(2686), 1, + ACTIONS(2612), 1, + sym_identifier, + STATE(1211), 1, + sym_symbol_path, + [58052] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2469), 2, anon_sym_COMMA, - [56116] = 3, + anon_sym_GT, + [58060] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2688), 1, - anon_sym_LBRACE, - ACTIONS(2690), 1, + ACTIONS(2682), 1, + anon_sym_EQ, + ACTIONS(2684), 1, anon_sym_LT, - [56126] = 3, + [58070] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2311), 1, + ACTIONS(2546), 2, anon_sym_COMMA, - STATE(1131), 1, - aux_sym_tuple_pattern_repeat1, - [56136] = 2, + anon_sym_RPAREN, + [58078] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1174), 2, - sym__statement_break, - anon_sym_where, - [56144] = 3, + ACTIONS(1748), 1, + anon_sym_LBRACE, + ACTIONS(1754), 1, + anon_sym_LPAREN, + [58088] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 1, + ACTIONS(2686), 1, sym_identifier, - STATE(1105), 1, - sym_symbol_path, - [56154] = 2, + STATE(1025), 1, + sym_qualified_path, + [58098] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1754), 2, - anon_sym_LBRACE, - anon_sym_EQ, - [56162] = 3, + ACTIONS(2688), 1, + anon_sym_RBRACE, + ACTIONS(2690), 1, + anon_sym_COMMA, + [58108] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - sym_identifier, - STATE(1302), 1, - sym_field_assignment, - [56172] = 3, + ACTIONS(2350), 1, + anon_sym_COMMA, + STATE(1151), 1, + aux_sym_tuple_pattern_repeat1, + [58118] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2692), 1, - anon_sym_DASH_GT, + anon_sym_EQ, ACTIONS(2694), 1, - anon_sym_EQ_GT, - [56182] = 3, + anon_sym_LT, + [58128] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2696), 1, - anon_sym_COLON, + anon_sym_LT, ACTIONS(2698), 1, - anon_sym_EQ, - [56192] = 3, + anon_sym_LPAREN, + [58138] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2700), 1, sym_identifier, - STATE(1239), 1, - sym_qualified_path, - [56202] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2534), 1, - sym_identifier, - STATE(1700), 1, - sym_field_pattern, - [56212] = 3, + STATE(1277), 1, + sym_named_argument, + [58148] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2570), 1, - anon_sym_LPAREN, ACTIONS(2702), 1, sym_identifier, - [56222] = 3, + STATE(833), 1, + sym_symbol_path, + [58158] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2704), 1, + ACTIONS(2612), 1, sym_identifier, - STATE(1244), 1, - sym_qualified_path, - [56232] = 2, + STATE(1144), 1, + sym_symbol_path, + [58168] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2706), 2, - anon_sym_COMMA, - anon_sym_GT, - [56240] = 2, + ACTIONS(2704), 1, + anon_sym_DASH_GT, + ACTIONS(2706), 1, + anon_sym_EQ_GT, + [58178] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2708), 1, - anon_sym_LPAREN, - [56247] = 2, - ACTIONS(298), 1, - sym_line_comment, + anon_sym_LBRACE, ACTIONS(2710), 1, - sym_identifier, - [56254] = 2, + anon_sym_LT, + [58188] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2712), 1, - anon_sym_COLON, - [56261] = 2, + ACTIONS(2712), 2, + anon_sym_COMMA, + anon_sym_GT, + [58196] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2714), 1, - anon_sym_EQ, - [56268] = 2, + ACTIONS(2069), 2, + anon_sym_LBRACE, + anon_sym_SEMI, + [58204] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2716), 1, - anon_sym_GT, - [56275] = 2, + ACTIONS(1728), 1, + sym_static_stage, + ACTIONS(1730), 1, + anon_sym_effect, + [58214] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1881), 1, - anon_sym_COLON, - [56282] = 2, + ACTIONS(1264), 2, + sym__statement_break, + anon_sym_where, + [58222] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1514), 1, - sym__statement_break, - [56289] = 2, + ACTIONS(2147), 1, + sym_identifier, + STATE(1318), 1, + sym_import_member, + [58232] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1410), 1, - sym__statement_break, - [56296] = 2, + ACTIONS(2714), 1, + anon_sym_DASH_GT, + ACTIONS(2716), 1, + anon_sym_EQ_GT, + [58242] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2718), 1, sym_identifier, - [56303] = 2, + STATE(1252), 1, + sym_qualified_path, + [58252] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2720), 1, - sym__statement_break, - [56310] = 2, + anon_sym_COLON, + STATE(922), 1, + sym_signature_ascription, + [58262] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2722), 1, - anon_sym_EQ_GT, - [56317] = 2, + ACTIONS(2562), 1, + sym_identifier, + STATE(1360), 1, + sym_field_pattern, + [58272] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2724), 1, + ACTIONS(2722), 1, anon_sym_COLON, - [56324] = 2, + ACTIONS(2724), 1, + anon_sym_EQ, + [58282] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1246), 2, + sym__statement_break, + anon_sym_where, + [58290] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2726), 1, - anon_sym_LPAREN, - [56331] = 2, + sym_identifier, + STATE(1258), 1, + sym_qualified_path, + [58300] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(1398), 1, + sym__statement_break, ACTIONS(2728), 1, - anon_sym_RPAREN, - [56338] = 2, + anon_sym_DASH_GT, + [58310] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2730), 1, - sym__statement_break, - [56345] = 2, + ACTIONS(2562), 1, + sym_identifier, + STATE(1737), 1, + sym_field_pattern, + [58320] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2130), 1, + sym_identifier, + STATE(1276), 1, + sym_extern_parameter, + [58330] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2730), 1, + anon_sym_LT, ACTIONS(2732), 1, - anon_sym_EQ_GT, - [56352] = 2, + anon_sym_LPAREN, + [58340] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2404), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + [58348] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2734), 1, - anon_sym_DASH_GT, - [56359] = 2, + anon_sym_RBRACE, + [58355] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2736), 1, - anon_sym_RBRACE, - [56366] = 2, + anon_sym_type, + [58362] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2738), 1, - anon_sym_RPAREN, - [56373] = 2, + anon_sym_LPAREN2, + [58369] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2740), 1, - anon_sym_COLON, - [56380] = 2, + anon_sym_RBRACE, + [58376] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1526), 1, + sym__statement_break, + [58383] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2742), 1, - anon_sym_LPAREN, - [56387] = 2, + anon_sym_GT, + [58390] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2744), 1, - anon_sym_PIPE, - [56394] = 2, + anon_sym_EQ, + [58397] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2746), 1, - anon_sym_EQ_GT, - [56401] = 2, + anon_sym_COLON, + [58404] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2748), 1, - sym__statement_break, - [56408] = 2, + anon_sym_RPAREN, + [58411] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1516), 1, - sym__statement_break, - [56415] = 2, + ACTIONS(2750), 1, + anon_sym_COLON, + [58418] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1438), 1, - sym__statement_break, - [56422] = 2, + ACTIONS(2752), 1, + anon_sym_RBRACE, + [58425] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2750), 1, + ACTIONS(2754), 1, anon_sym_LPAREN, - [56429] = 2, + [58432] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2752), 1, - anon_sym_RPAREN, - [56436] = 2, + ACTIONS(1488), 1, + sym__statement_break, + [58439] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2754), 1, - anon_sym_RBRACE, - [56443] = 2, + ACTIONS(2756), 1, + anon_sym_LPAREN, + [58446] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2756), 1, - sym_identifier, - [56450] = 2, + ACTIONS(2758), 1, + anon_sym_RPAREN, + [58453] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1350), 1, + ACTIONS(2760), 1, + anon_sym_DASH_GT, + [58460] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1528), 1, sym__statement_break, - [56457] = 2, + [58467] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2758), 1, - anon_sym_EQ, - [56464] = 2, + ACTIONS(1712), 1, + anon_sym_RPAREN, + [58474] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2760), 1, - anon_sym_module, - [56471] = 2, + ACTIONS(1444), 1, + sym__statement_break, + [58481] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2762), 1, - anon_sym_GT, - [56478] = 2, + anon_sym_DASH_GT, + [58488] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2764), 1, - anon_sym_LPAREN, - [56485] = 2, + anon_sym_RBRACE, + [58495] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2766), 1, - anon_sym_module, - [56492] = 2, + anon_sym_RPAREN, + [58502] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2768), 1, - anon_sym_LBRACE, - [56499] = 2, + anon_sym_RPAREN, + [58509] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2694), 1, - anon_sym_EQ_GT, - [56506] = 2, + ACTIONS(2770), 1, + anon_sym_LPAREN, + [58516] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2770), 1, - anon_sym_extra, - [56513] = 2, + ACTIONS(1530), 1, + sym__statement_break, + [58523] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2772), 1, - anon_sym_LBRACE, - [56520] = 2, + anon_sym_LPAREN, + [58530] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2774), 1, - anon_sym_DASH_GT, - [56527] = 2, + anon_sym_EQ_GT, + [58537] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2776), 1, - anon_sym_GT, - [56534] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2778), 1, - anon_sym_RBRACK, - [56541] = 2, + anon_sym_RPAREN, + [58544] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2780), 1, - anon_sym_EQ, - [56548] = 2, + ACTIONS(1448), 1, + sym__statement_break, + [58551] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1522), 1, + ACTIONS(1532), 1, sym__statement_break, - [56555] = 2, + [58558] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1440), 1, + ACTIONS(1432), 1, sym__statement_break, - [56562] = 2, + [58565] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2782), 1, - anon_sym_EQ_GT, - [56569] = 2, + ACTIONS(2778), 1, + anon_sym_RPAREN, + [58572] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1442), 1, - sym__statement_break, - [56576] = 2, + ACTIONS(2780), 1, + anon_sym_RBRACE, + [58579] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1524), 1, - sym__statement_break, - [56583] = 2, + ACTIONS(2782), 1, + sym_identifier, + [58586] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2784), 1, - anon_sym_LPAREN, - [56590] = 2, + anon_sym_EQ, + [58593] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1432), 1, + ACTIONS(2786), 1, + anon_sym_EQ, + [58600] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1366), 1, sym__statement_break, - [56597] = 2, + [58607] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2786), 1, - sym_identifier, - [56604] = 2, + ACTIONS(1536), 1, + sym__statement_break, + [58614] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2788), 1, - anon_sym_EQ_GT, - [56611] = 2, + sym_identifier, + [58621] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1362), 1, - sym__statement_break, - [56618] = 2, + ACTIONS(2790), 1, + anon_sym_GT, + [58628] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2790), 1, - anon_sym_else, - [56625] = 2, + ACTIONS(1538), 1, + sym__statement_break, + [58635] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1444), 1, + ACTIONS(1410), 1, sym__statement_break, - [56632] = 2, + [58642] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2792), 1, - anon_sym_RBRACE, - [56639] = 2, + anon_sym_extra, + [58649] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2794), 1, - anon_sym_RBRACE, - [56646] = 2, + anon_sym_LBRACE, + [58656] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2796), 1, - anon_sym_RPAREN, - [56653] = 2, + anon_sym_DASH_GT, + [58663] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2798), 1, - sym_identifier, - [56660] = 2, + anon_sym_GT, + [58670] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2800), 1, - sym__statement_break, - [56667] = 2, + anon_sym_RBRACK, + [58677] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2802), 1, - anon_sym_RPAREN, - [56674] = 2, + anon_sym_EQ, + [58684] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1450), 1, + sym__statement_break, + [58691] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2804), 1, + anon_sym_EQ_GT, + [58698] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1490), 1, + sym__statement_break, + [58705] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1452), 1, sym__statement_break, - [56681] = 2, + [58712] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(498), 1, + ACTIONS(1454), 1, sym__statement_break, - [56688] = 2, + [58719] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2806), 1, - anon_sym_DASH_GT, - [56695] = 2, + anon_sym_PIPE, + [58726] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1446), 1, + ACTIONS(1540), 1, sym__statement_break, - [56702] = 2, + [58733] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1364), 1, + ACTIONS(1456), 1, sym__statement_break, - [56709] = 2, + [58740] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2808), 1, - anon_sym_RBRACE, - [56716] = 2, + anon_sym_EQ_GT, + [58747] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2810), 1, - anon_sym_RPAREN, - [56723] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2812), 1, - anon_sym_EQ, - [56730] = 2, + anon_sym_extra, + [58754] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2814), 1, - anon_sym_RPAREN, - [56737] = 2, + ACTIONS(1498), 1, + sym__statement_break, + [58761] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2816), 1, - anon_sym_effect, - [56744] = 2, + ACTIONS(2812), 1, + sym_identifier, + [58768] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1420), 1, + ACTIONS(1542), 1, sym__statement_break, - [56751] = 2, + [58775] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1526), 1, - sym__statement_break, - [56758] = 2, + ACTIONS(2814), 1, + anon_sym_RBRACE, + [58782] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1448), 1, - sym__statement_break, - [56765] = 2, + ACTIONS(2816), 1, + anon_sym_RPAREN, + [58789] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2818), 1, - sym_identifier, - [56772] = 2, + anon_sym_COLON, + [58796] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2820), 1, - anon_sym_RBRACK, - [56779] = 2, + anon_sym_RBRACE, + [58803] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2822), 1, - anon_sym_LPAREN, - [56786] = 2, + anon_sym_RPAREN, + [58810] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2824), 1, - anon_sym_COLON, - [56793] = 2, + anon_sym_GT, + [58817] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2826), 1, - sym_identifier, - [56800] = 2, + anon_sym_RPAREN, + [58824] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2828), 1, - anon_sym_EQ_GT, - [56807] = 2, + anon_sym_DASH_GT, + [58831] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2830), 1, - anon_sym_RPAREN, - [56814] = 2, + ACTIONS(1544), 1, + sym__statement_break, + [58838] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1406), 1, - sym__statement_break, - [56821] = 2, + ACTIONS(2830), 1, + ts_builtin_sym_end, + [58845] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2832), 1, sym_identifier, - [56828] = 2, + [58852] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2834), 1, - anon_sym_LBRACE, - [56835] = 2, + anon_sym_RPAREN, + [58859] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1450), 1, - sym__statement_break, - [56842] = 2, + ACTIONS(2836), 1, + anon_sym_EQ, + [58866] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1404), 1, + ACTIONS(1458), 1, sym__statement_break, - [56849] = 2, + [58873] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2836), 1, - anon_sym_LBRACE, - [56856] = 2, + ACTIONS(2838), 1, + anon_sym_RBRACK, + [58880] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1416), 1, + ACTIONS(1508), 1, sym__statement_break, - [56863] = 2, + [58887] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2838), 1, - anon_sym_DOT_DOT, - [56870] = 2, + ACTIONS(1546), 1, + sym__statement_break, + [58894] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2840), 1, - anon_sym_LBRACE, - [56877] = 2, + anon_sym_GT, + [58901] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2842), 1, - sym_identifier, - [56884] = 2, + anon_sym_DASH_GT, + [58908] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2844), 1, - anon_sym_COLON, - [56891] = 2, + anon_sym_RBRACK, + [58915] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1548), 1, + sym__statement_break, + [58922] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2846), 1, - sym_identifier, - [56898] = 2, + anon_sym_RPAREN, + [58929] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2848), 1, - anon_sym_COLON, - [56905] = 2, + anon_sym_RPAREN, + [58936] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2850), 1, - anon_sym_EQ_GT, - [56912] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1422), 1, - sym__statement_break, - [56919] = 2, + anon_sym_GT, + [58943] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2852), 1, - anon_sym_COLON, - [56926] = 2, + anon_sym_RPAREN, + [58950] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2854), 1, - anon_sym_COLON, - [56933] = 2, + ACTIONS(1460), 1, + sym__statement_break, + [58957] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1424), 1, + ACTIONS(1462), 1, sym__statement_break, - [56940] = 2, + [58964] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2856), 1, - sym__statement_break, - [56947] = 2, + ACTIONS(2854), 1, + anon_sym_RBRACK, + [58971] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1426), 1, - sym__statement_break, - [56954] = 2, + ACTIONS(1023), 1, + anon_sym_RPAREN, + [58978] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(685), 1, + ACTIONS(1554), 1, sym__statement_break, - [56961] = 2, + [58985] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2327), 1, - anon_sym_RBRACE, - [56968] = 2, + ACTIONS(2632), 1, + anon_sym_EQ_GT, + [58992] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2856), 1, + sym_identifier, + [58999] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2858), 1, - anon_sym_GT, - [56975] = 2, + anon_sym_fn, + [59006] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2860), 1, - anon_sym_COLON, - [56982] = 2, + anon_sym_QMARK, + [59013] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1823), 1, - anon_sym_COLON, - [56989] = 2, + ACTIONS(2862), 1, + sym_identifier, + [59020] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1494), 1, - sym__statement_break, - [56996] = 2, + ACTIONS(2864), 1, + anon_sym_effect, + [59027] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2862), 1, + ACTIONS(2866), 1, + sym_identifier, + [59034] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2868), 1, + anon_sym_LPAREN2, + [59041] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2870), 1, anon_sym_RBRACE, - [57003] = 2, + [59048] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2864), 1, + ACTIONS(2872), 1, anon_sym_RPAREN, - [57010] = 2, + [59055] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1428), 1, + ACTIONS(1378), 1, sym__statement_break, - [57017] = 2, + [59062] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1552), 1, + ACTIONS(2874), 1, sym__statement_break, - [57024] = 2, + [59069] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1454), 1, - sym__statement_break, - [57031] = 2, + ACTIONS(2876), 1, + anon_sym_EQ, + [59076] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2866), 1, + ACTIONS(2878), 1, sym__statement_break, - [57038] = 2, + [59083] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2868), 1, - anon_sym_LPAREN, - [57045] = 2, + ACTIONS(2880), 1, + anon_sym_GT, + [59090] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1502), 1, - sym__statement_break, - [57052] = 2, + ACTIONS(2882), 1, + anon_sym_module, + [59097] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2870), 1, + ACTIONS(2884), 1, + anon_sym_RPAREN, + [59104] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2886), 1, sym_identifier, - [57059] = 2, + [59111] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2872), 1, - anon_sym_LBRACE, - [57066] = 2, + ACTIONS(2888), 1, + anon_sym_COLON, + [59118] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2874), 1, - anon_sym_RBRACE, - [57073] = 2, + ACTIONS(2890), 1, + anon_sym_GT, + [59125] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1456), 1, - sym__statement_break, - [57080] = 2, + ACTIONS(2892), 1, + sym_identifier, + [59132] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2876), 1, + ACTIONS(2894), 1, anon_sym_COLON, - [57087] = 2, + [59139] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2878), 1, - anon_sym_RPAREN, - [57094] = 2, + ACTIONS(2896), 1, + anon_sym_COLON, + [59146] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2880), 1, - anon_sym_EQ_GT, - [57101] = 2, + ACTIONS(2898), 1, + anon_sym_LPAREN, + [59153] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2882), 1, - anon_sym_RBRACE, - [57108] = 2, + ACTIONS(1412), 1, + sym__statement_break, + [59160] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1458), 1, + ACTIONS(1396), 1, sym__statement_break, - [57115] = 2, + [59167] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2884), 1, - anon_sym_EQ, - [57122] = 2, + ACTIONS(2900), 1, + sym__statement_break, + [59174] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2886), 1, - sym_identifier, - [57129] = 2, + ACTIONS(2902), 1, + anon_sym_GT, + [59181] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2888), 1, - sym_identifier, - [57136] = 2, + ACTIONS(2904), 1, + anon_sym_effect, + [59188] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1460), 1, - sym__statement_break, - [57143] = 2, + ACTIONS(2906), 1, + anon_sym_LBRACE, + [59195] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1462), 1, - sym__statement_break, - [57150] = 2, + ACTIONS(2908), 1, + anon_sym_RBRACK, + [59202] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2890), 1, + ACTIONS(2910), 1, + anon_sym_RBRACE, + [59209] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2912), 1, sym_identifier, - [57157] = 2, + [59216] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1412), 1, + ACTIONS(1520), 1, sym__statement_break, - [57164] = 2, + [59223] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2548), 1, + ACTIONS(2914), 1, + anon_sym_GT, + [59230] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2916), 1, anon_sym_EQ_GT, - [57171] = 2, + [59237] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2892), 1, + ACTIONS(2918), 1, anon_sym_LBRACE, - [57178] = 2, + [59244] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1414), 1, + ACTIONS(1522), 1, sym__statement_break, - [57185] = 2, + [59251] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2894), 1, + ACTIONS(2920), 1, sym_identifier, - [57192] = 2, + [59258] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1430), 1, - sym__statement_break, - [57199] = 2, + ACTIONS(2922), 1, + sym_identifier, + [59265] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2924), 1, + sym_identifier, + [59272] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2926), 1, + sym_identifier, + [59279] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2928), 1, + anon_sym_RPAREN, + [59286] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(1464), 1, sym__statement_break, - [57206] = 2, + [59293] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2896), 1, - anon_sym_LPAREN, - [57213] = 2, + ACTIONS(2930), 1, + sym__statement_break, + [59300] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2476), 1, - anon_sym_RBRACE, - [57220] = 2, + ACTIONS(2568), 1, + anon_sym_EQ_GT, + [59307] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2898), 1, + ACTIONS(2932), 1, + sym_identifier, + [59314] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2934), 1, + anon_sym_GT, + [59321] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2936), 1, anon_sym_RBRACE, - [57227] = 2, + [59328] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2900), 1, - sym_identifier, - [57234] = 2, + ACTIONS(2938), 1, + anon_sym_RPAREN, + [59335] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2902), 1, + ACTIONS(2940), 1, anon_sym_LBRACE, - [57241] = 2, + [59342] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2904), 1, - sym_identifier, - [57248] = 2, + ACTIONS(2942), 1, + anon_sym_GT, + [59349] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2906), 1, - anon_sym_RBRACE, - [57255] = 2, + ACTIONS(2944), 1, + anon_sym_GT, + [59356] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2908), 1, + ACTIONS(2946), 1, anon_sym_RBRACE, - [57262] = 2, + [59363] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2910), 1, - anon_sym_LPAREN, - [57269] = 2, + ACTIONS(2948), 1, + anon_sym_EQ_GT, + [59370] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2912), 1, - anon_sym_RPAREN, - [57276] = 2, + ACTIONS(2950), 1, + sym__statement_break, + [59377] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2914), 1, + ACTIONS(2952), 1, + anon_sym_EQ_GT, + [59384] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2954), 1, + anon_sym_RBRACE, + [59391] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2956), 1, + anon_sym_RBRACE, + [59398] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2958), 1, sym_identifier, - [57283] = 2, + [59405] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2916), 1, + ACTIONS(1534), 1, + sym__statement_break, + [59412] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2960), 1, + sym__statement_break, + [59419] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2962), 1, + anon_sym_RBRACE, + [59426] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2964), 1, anon_sym_DASH_GT, - [57290] = 2, + [59433] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2918), 1, + ACTIONS(2966), 1, anon_sym_RBRACE, - [57297] = 2, + [59440] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2920), 1, + ACTIONS(2968), 1, anon_sym_RPAREN, - [57304] = 2, + [59447] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2922), 1, + ACTIONS(2970), 1, + anon_sym_RPAREN, + [59454] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2972), 1, anon_sym_EQ_GT, - [57311] = 2, + [59461] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1528), 1, - sym__statement_break, - [57318] = 2, + ACTIONS(2974), 1, + anon_sym_EQ_GT, + [59468] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1530), 1, + ACTIONS(1466), 1, sym__statement_break, - [57325] = 2, + [59475] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1504), 1, + ACTIONS(568), 1, sym__statement_break, - [57332] = 2, + [59482] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2924), 1, + ACTIONS(2976), 1, anon_sym_DASH_GT, - [57339] = 2, + [59489] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2926), 1, + ACTIONS(2978), 1, anon_sym_GT, - [57346] = 2, + [59496] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2928), 1, + ACTIONS(2980), 1, anon_sym_RBRACK, - [57353] = 2, + [59503] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2930), 1, + ACTIONS(2982), 1, anon_sym_EQ_GT, - [57360] = 2, + [59510] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2932), 1, - anon_sym_EQ_GT, - [57367] = 2, + ACTIONS(2984), 1, + sym__statement_break, + [59517] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2934), 1, + ACTIONS(2986), 1, anon_sym_RPAREN, - [57374] = 2, + [59524] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1678), 1, - anon_sym_type, - [57381] = 2, + ACTIONS(2988), 1, + sym_identifier, + [59531] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2936), 1, + ACTIONS(2990), 1, anon_sym_DASH_GT, - [57388] = 2, + [59538] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2938), 1, - anon_sym_LBRACE, - [57395] = 2, + ACTIONS(2992), 1, + anon_sym_LPAREN, + [59545] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2940), 1, + ACTIONS(2994), 1, anon_sym_RPAREN, - [57402] = 2, + [59552] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1482), 1, + ACTIONS(1468), 1, sym__statement_break, - [57409] = 2, + [59559] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1787), 1, - anon_sym_LBRACE, - [57416] = 2, + ACTIONS(2996), 1, + sym_identifier, + [59566] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2942), 1, + ACTIONS(2998), 1, sym_identifier, - [57423] = 2, + [59573] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1532), 1, - sym__statement_break, - [57430] = 2, + ACTIONS(3000), 1, + anon_sym_LPAREN, + [59580] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2944), 1, - sym_identifier, - [57437] = 2, + ACTIONS(1564), 1, + sym__statement_break, + [59587] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2946), 1, + ACTIONS(3002), 1, sym_identifier, - [57444] = 2, + [59594] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1466), 1, + ACTIONS(1418), 1, sym__statement_break, - [57451] = 2, + [59601] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2948), 1, + ACTIONS(3004), 1, sym_identifier, - [57458] = 2, + [59608] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2950), 1, + ACTIONS(3006), 1, sym_identifier, - [57465] = 2, + [59615] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2952), 1, + ACTIONS(3008), 1, sym_identifier, - [57472] = 2, + [59622] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2954), 1, - anon_sym_extra, - [57479] = 2, + ACTIONS(3010), 1, + sym_identifier, + [59629] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2956), 1, - anon_sym_RPAREN, - [57486] = 2, + ACTIONS(3012), 1, + anon_sym_LBRACE, + [59636] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2958), 1, - anon_sym_LPAREN, - [57493] = 2, + ACTIONS(3014), 1, + anon_sym_EQ_GT, + [59643] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2960), 1, - anon_sym_LPAREN, - [57500] = 2, + ACTIONS(1472), 1, + sym__statement_break, + [59650] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2570), 1, + ACTIONS(3016), 1, anon_sym_LPAREN, - [57507] = 2, + [59657] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1506), 1, + ACTIONS(1474), 1, sym__statement_break, - [57514] = 2, + [59664] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2962), 1, - anon_sym_PIPE, - [57521] = 2, + ACTIONS(2582), 1, + anon_sym_LPAREN, + [59671] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2964), 1, - anon_sym_GT, - [57528] = 2, + ACTIONS(3018), 1, + anon_sym_LPAREN, + [59678] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2966), 1, - anon_sym_COLON, - [57535] = 2, + ACTIONS(3020), 1, + anon_sym_PIPE, + [59685] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2968), 1, + ACTIONS(1476), 1, sym__statement_break, - [57542] = 2, + [59692] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1486), 1, + ACTIONS(3022), 1, + sym_identifier, + [59699] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1566), 1, sym__statement_break, - [57549] = 2, + [59706] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2970), 1, - anon_sym_DASH_GT, - [57556] = 2, + ACTIONS(3024), 1, + anon_sym_LBRACE, + [59713] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2972), 1, + ACTIONS(3026), 1, sym_identifier, - [57563] = 2, + [59720] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2974), 1, - sym_identifier, - [57570] = 2, + ACTIONS(1478), 1, + sym__statement_break, + [59727] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2976), 1, - anon_sym_GT, - [57577] = 2, + ACTIONS(3028), 1, + anon_sym_LPAREN, + [59734] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2978), 1, + ACTIONS(600), 1, + sym__statement_break, + [59741] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3030), 1, anon_sym_LBRACE, - [57584] = 2, + [59748] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2980), 1, - anon_sym_RPAREN, - [57591] = 2, + ACTIONS(3032), 1, + anon_sym_EQ_GT, + [59755] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2982), 1, - sym_identifier, - [57598] = 2, + ACTIONS(1434), 1, + sym__statement_break, + [59762] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2984), 1, + ACTIONS(3034), 1, anon_sym_LPAREN, - [57605] = 2, + [59769] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2986), 1, - sym_identifier, - [57612] = 2, + ACTIONS(1480), 1, + sym__statement_break, + [59776] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1468), 1, - sym__statement_break, - [57619] = 2, + ACTIONS(3036), 1, + anon_sym_LPAREN2, + [59783] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2988), 1, + ACTIONS(3038), 1, + anon_sym_LBRACE, + [59790] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3040), 1, sym_identifier, - [57626] = 2, + [59797] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2990), 1, + ACTIONS(3042), 1, sym_identifier, - [57633] = 2, + [59804] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2992), 1, - anon_sym_COLON, - [57640] = 2, + ACTIONS(3044), 1, + anon_sym_LPAREN, + [59811] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2994), 1, + ACTIONS(3046), 1, anon_sym_RPAREN, - [57647] = 2, + [59818] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1508), 1, - sym__statement_break, - [57654] = 2, + ACTIONS(3048), 1, + anon_sym_COLON, + [59825] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2996), 1, + ACTIONS(3050), 1, anon_sym_LPAREN, - [57661] = 2, + [59832] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1554), 1, - sym__statement_break, - [57668] = 2, + ACTIONS(3052), 1, + anon_sym_RPAREN, + [59839] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2998), 1, - anon_sym_COLON, - [57675] = 2, + ACTIONS(3054), 1, + anon_sym_RBRACE, + [59846] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3000), 1, - anon_sym_type, - [57682] = 2, + ACTIONS(1482), 1, + sym__statement_break, + [59853] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1470), 1, - sym__statement_break, - [57689] = 2, + ACTIONS(3056), 1, + anon_sym_RPAREN, + [59860] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3002), 1, - anon_sym_DASH_GT, - [57696] = 2, + ACTIONS(3058), 1, + sym_identifier, + [59867] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3004), 1, - anon_sym_COLON, - [57703] = 2, + ACTIONS(3060), 1, + anon_sym_LBRACE, + [59874] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3006), 1, + ACTIONS(3062), 1, sym_identifier, - [57710] = 2, + [59881] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3008), 1, - anon_sym_RPAREN, - [57717] = 2, + ACTIONS(1486), 1, + sym__statement_break, + [59888] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1434), 1, + ACTIONS(1420), 1, sym__statement_break, - [57724] = 2, + [59895] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1474), 1, + ACTIONS(1436), 1, sym__statement_break, - [57731] = 2, + [59902] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3010), 1, + ACTIONS(3064), 1, anon_sym_LBRACE, - [57738] = 2, + [59909] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3012), 1, - anon_sym_LPAREN, - [57745] = 2, + ACTIONS(3066), 1, + anon_sym_COLON, + [59916] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3014), 1, + ACTIONS(3068), 1, anon_sym_RPAREN, - [57752] = 2, + [59923] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1390), 1, - sym__statement_break, - [57759] = 2, + ACTIONS(3070), 1, + anon_sym_RBRACE, + [59930] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3016), 1, + ACTIONS(3072), 1, anon_sym_GT, - [57766] = 2, + [59937] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3018), 1, - anon_sym_GT, - [57773] = 2, + ACTIONS(3074), 1, + anon_sym_module, + [59944] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3020), 1, - anon_sym_RBRACK, - [57780] = 2, + ACTIONS(3076), 1, + sym__statement_break, + [59951] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3022), 1, + ACTIONS(3078), 1, anon_sym_LPAREN, - [57787] = 2, + [59958] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3024), 1, + ACTIONS(3080), 1, anon_sym_LBRACE, - [57794] = 2, + [59965] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3026), 1, - anon_sym_DOT, - [57801] = 2, + ACTIONS(3082), 1, + sym__statement_break, + [59972] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1716), 1, anon_sym_RPAREN, - [57808] = 2, + [59979] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1476), 1, + ACTIONS(1404), 1, sym__statement_break, - [57815] = 2, + [59986] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1534), 1, - sym__statement_break, - [57822] = 2, + ACTIONS(3084), 1, + anon_sym_LBRACE, + [59993] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3028), 1, - anon_sym_fn, - [57829] = 2, + ACTIONS(3086), 1, + sym_identifier, + [60000] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3030), 1, - anon_sym_RBRACE, - [57836] = 2, + ACTIONS(1422), 1, + sym__statement_break, + [60007] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3032), 1, + ACTIONS(3088), 1, anon_sym_LPAREN, - [57843] = 2, + [60014] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1436), 1, + ACTIONS(1470), 1, sym__statement_break, - [57850] = 2, + [60021] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1478), 1, - sym__statement_break, - [57857] = 2, + ACTIONS(3090), 1, + anon_sym_EQ_GT, + [60028] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3034), 1, + ACTIONS(3092), 1, anon_sym_LBRACE, - [57864] = 2, + [60035] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3036), 1, - anon_sym_RPAREN, - [57871] = 2, + ACTIONS(3094), 1, + anon_sym_RBRACK, + [60042] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1536), 1, - sym__statement_break, - [57878] = 2, + ACTIONS(3096), 1, + anon_sym_fn, + [60049] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3038), 1, - anon_sym_RPAREN, - [57885] = 2, + ACTIONS(3098), 1, + anon_sym_LPAREN, + [60056] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3040), 1, + ACTIONS(3100), 1, anon_sym_EQ, - [57892] = 2, + [60063] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3042), 1, + ACTIONS(3102), 1, anon_sym_LBRACE, - [57899] = 2, + [60070] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3044), 1, + ACTIONS(3104), 1, anon_sym_else, - [57906] = 2, + [60077] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3046), 1, + ACTIONS(3106), 1, anon_sym_LPAREN, - [57913] = 2, + [60084] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3048), 1, + ACTIONS(3108), 1, anon_sym_RPAREN, - [57920] = 2, + [60091] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1396), 1, - sym__statement_break, - [57927] = 2, + ACTIONS(3110), 1, + anon_sym_COLON, + [60098] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3050), 1, + ACTIONS(3112), 1, anon_sym_RPAREN, - [57934] = 2, + [60105] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3052), 1, + ACTIONS(3114), 1, anon_sym_GT, - [57941] = 2, + [60112] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3054), 1, + ACTIONS(3116), 1, anon_sym_LBRACE, - [57948] = 2, + [60119] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3056), 1, - sym_identifier, - [57955] = 2, + ACTIONS(3118), 1, + anon_sym_COLON, + [60126] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3058), 1, - anon_sym_GT, - [57962] = 2, + ACTIONS(1392), 1, + sym__statement_break, + [60133] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, - sym__statement_break, - [57969] = 2, + ACTIONS(3120), 1, + sym_identifier, + [60140] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3060), 1, + ACTIONS(3122), 1, anon_sym_LBRACE, - [57976] = 2, + [60147] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3062), 1, - anon_sym_LBRACE, - [57983] = 2, + ACTIONS(3124), 1, + anon_sym_GT, + [60154] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3064), 1, + ACTIONS(3126), 1, anon_sym_LBRACE, - [57990] = 2, + [60161] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3066), 1, + ACTIONS(3128), 1, anon_sym_RPAREN, - [57997] = 2, + [60168] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1538), 1, - sym__statement_break, - [58004] = 2, + ACTIONS(3130), 1, + anon_sym_COLON, + [60175] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3068), 1, - anon_sym_DASH_GT, - [58011] = 2, + ACTIONS(3132), 1, + anon_sym_COLON, + [60182] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1710), 1, - anon_sym_RPAREN, - [58018] = 2, + ACTIONS(3134), 1, + anon_sym_GT, + [60189] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3070), 1, + ACTIONS(3136), 1, anon_sym_LBRACE, - [58025] = 2, + [60196] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1540), 1, - sym__statement_break, - [58032] = 2, + ACTIONS(3138), 1, + anon_sym_RPAREN, + [60203] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3072), 1, + ACTIONS(3140), 1, anon_sym_RPAREN, - [58039] = 2, + [60210] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1542), 1, - sym__statement_break, - [58046] = 2, + ACTIONS(3142), 1, + sym_identifier, + [60217] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3074), 1, - anon_sym_effect, - [58053] = 2, + ACTIONS(3144), 1, + anon_sym_COLON, + [60224] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(1492), 1, sym__statement_break, - [58060] = 2, + [60231] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3076), 1, - anon_sym_RBRACK, - [58067] = 2, + ACTIONS(1905), 1, + anon_sym_COLON, + [60238] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3078), 1, - sym__statement_break, - [58074] = 2, + ACTIONS(3146), 1, + anon_sym_COLON, + [60245] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3080), 1, - anon_sym_GT, - [58081] = 2, + ACTIONS(3148), 1, + anon_sym_COLON, + [60252] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3082), 1, + ACTIONS(3150), 1, anon_sym_LPAREN, - [58088] = 2, + [60259] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1544), 1, - sym__statement_break, - [58095] = 2, + ACTIONS(3152), 1, + anon_sym_LPAREN, + [60266] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3084), 1, + ACTIONS(3154), 1, anon_sym_PIPE, - [58102] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3086), 1, - anon_sym_RBRACE, - [58109] = 2, + [60273] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3088), 1, - sym_identifier, - [58116] = 2, + ACTIONS(1494), 1, + sym__statement_break, + [60280] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1496), 1, sym__statement_break, - [58123] = 2, + [60287] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1500), 1, + ACTIONS(3156), 1, sym__statement_break, - [58130] = 2, + [60294] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3090), 1, - ts_builtin_sym_end, - [58137] = 2, + ACTIONS(3158), 1, + anon_sym_COLON, + [60301] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3092), 1, - sym_identifier, - [58144] = 2, + ACTIONS(1889), 1, + anon_sym_COLON, + [60308] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3094), 1, + ACTIONS(1424), 1, sym__statement_break, - [58151] = 2, + [60315] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3096), 1, - anon_sym_LPAREN, - [58158] = 2, + ACTIONS(3160), 1, + sym_identifier, + [60322] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3098), 1, - anon_sym_RPAREN, - [58165] = 2, + ACTIONS(3162), 1, + anon_sym_LPAREN, + [60329] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3100), 1, + ACTIONS(1500), 1, sym__statement_break, - [58172] = 2, + [60336] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3102), 1, + ACTIONS(3164), 1, + anon_sym_LPAREN2, + [60343] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3166), 1, + anon_sym_COLON, + [60350] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3168), 1, anon_sym_RPAREN, - [58179] = 2, + [60357] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3104), 1, - anon_sym_LBRACE, - [58186] = 2, + ACTIONS(3170), 1, + anon_sym_RBRACE, + [60364] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1418), 1, - sym__statement_break, - [58193] = 2, + ACTIONS(3172), 1, + anon_sym_DOT, + [60371] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3106), 1, - anon_sym_EQ, - [58200] = 2, + ACTIONS(1502), 1, + sym__statement_break, + [60378] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1546), 1, + ACTIONS(1394), 1, sym__statement_break, - [58207] = 2, + [60385] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3108), 1, + ACTIONS(3174), 1, sym__statement_break, - [58214] = 2, + [60392] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3110), 1, - anon_sym_RBRACK, - [58221] = 2, + ACTIONS(3176), 1, + sym_identifier, + [60399] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3112), 1, - anon_sym_EQ, - [58228] = 2, + ACTIONS(1504), 1, + sym__statement_break, + [60406] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3114), 1, - anon_sym_RBRACE, - [58235] = 2, + ACTIONS(3178), 1, + anon_sym_LBRACE, + [60413] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3116), 1, + ACTIONS(3180), 1, anon_sym_LPAREN, - [58242] = 2, + [60420] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3118), 1, - anon_sym_RBRACE, - [58249] = 2, + ACTIONS(3182), 1, + anon_sym_LBRACE, + [60427] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1718), 1, + ACTIONS(1740), 1, anon_sym_RPAREN, - [58256] = 2, + [60434] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1374), 1, - sym__statement_break, - [58263] = 2, + ACTIONS(3184), 1, + anon_sym_LPAREN, + [60441] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3120), 1, - anon_sym_GT, - [58270] = 2, + ACTIONS(3186), 1, + sym_identifier, + [60448] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3122), 1, - anon_sym_COLON, - [58277] = 2, + ACTIONS(3188), 1, + anon_sym_else, + [60455] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3124), 1, + ACTIONS(3190), 1, anon_sym_else, - [58284] = 2, + [60462] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3126), 1, + ACTIONS(3192), 1, anon_sym_LPAREN, - [58291] = 2, + [60469] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3128), 1, + ACTIONS(3194), 1, anon_sym_RPAREN, - [58298] = 2, + [60476] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3130), 1, - anon_sym_RPAREN, - [58305] = 2, + ACTIONS(1506), 1, + sym__statement_break, + [60483] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1548), 1, - sym__statement_break, - [58312] = 2, + ACTIONS(2339), 1, + anon_sym_RBRACE, + [60490] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3132), 1, + ACTIONS(3196), 1, sym_identifier, - [58319] = 2, + [60497] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3134), 1, + ACTIONS(3198), 1, sym_identifier, - [58326] = 2, + [60504] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1550), 1, + ACTIONS(3200), 1, sym__statement_break, - [58333] = 2, + [60511] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1402), 1, + ACTIONS(1426), 1, sym__statement_break, - [58340] = 2, + [60518] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3136), 1, + ACTIONS(3202), 1, anon_sym_LBRACE, - [58347] = 2, + [60525] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3138), 1, + ACTIONS(3204), 1, anon_sym_LPAREN, - [58354] = 2, + [60532] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3140), 1, - sym_identifier, - [58361] = 2, + ACTIONS(3206), 1, + sym__statement_break, + [60539] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3142), 1, + ACTIONS(3208), 1, sym_identifier, - [58368] = 2, + [60546] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3144), 1, - anon_sym_EQ_GT, - [58375] = 2, + ACTIONS(3210), 1, + anon_sym_LBRACE, + [60553] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3146), 1, + ACTIONS(3212), 1, anon_sym_LPAREN, - [58382] = 2, + [60560] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3148), 1, + ACTIONS(3214), 1, sym_identifier, - [58389] = 2, + [60567] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3150), 1, + ACTIONS(3216), 1, sym_identifier, - [58396] = 2, + [60574] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1484), 1, + ACTIONS(1568), 1, sym__statement_break, - [58403] = 2, + [60581] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3152), 1, + ACTIONS(3218), 1, anon_sym_RPAREN, - [58410] = 2, + [60588] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3154), 1, + ACTIONS(3220), 1, anon_sym_LBRACE, - [58417] = 2, + [60595] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3156), 1, + ACTIONS(3222), 1, sym_identifier, - [58424] = 2, + [60602] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3158), 1, - anon_sym_GT, - [58431] = 2, + ACTIONS(3224), 1, + sym_identifier, + [60609] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3160), 1, + ACTIONS(3226), 1, sym_identifier, - [58438] = 2, + [60616] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3162), 1, - sym_identifier, - [58445] = 2, + ACTIONS(1438), 1, + sym__statement_break, + [60623] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1066), 1, - anon_sym_RPAREN, - [58452] = 2, + ACTIONS(1440), 1, + sym__statement_break, + [60630] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3164), 1, + ACTIONS(3228), 1, sym_identifier, - [58459] = 2, + [60637] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3166), 1, + ACTIONS(3230), 1, anon_sym_LPAREN, - [58466] = 2, + [60644] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3168), 1, - sym_identifier, - [58473] = 2, + ACTIONS(3232), 1, + sym__statement_break, + [60651] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3170), 1, + ACTIONS(3234), 1, sym_identifier, - [58480] = 2, + [60658] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3172), 1, + ACTIONS(3236), 1, sym_identifier, - [58487] = 2, + [60665] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3174), 1, + ACTIONS(3238), 1, sym_identifier, - [58494] = 2, + [60672] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3176), 1, + ACTIONS(3240), 1, anon_sym_GT, - [58501] = 2, + [60679] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3178), 1, - anon_sym_GT, - [58508] = 2, + ACTIONS(3242), 1, + anon_sym_RBRACE, + [60686] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3180), 1, + ACTIONS(3244), 1, sym_identifier, - [58515] = 2, + [60693] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3182), 1, + ACTIONS(3246), 1, anon_sym_QMARK, - [58522] = 2, + [60700] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3184), 1, - anon_sym_GT, - [58529] = 2, + ACTIONS(3248), 1, + anon_sym_EQ, + [60707] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3186), 1, + ACTIONS(3250), 1, anon_sym_LPAREN, - [58536] = 2, + [60714] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3188), 1, + ACTIONS(3252), 1, anon_sym_GT, - [58543] = 2, + [60721] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3190), 1, + ACTIONS(3254), 1, anon_sym_GT, - [58550] = 2, + [60728] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3192), 1, + ACTIONS(3256), 1, anon_sym_LPAREN, - [58557] = 2, + [60735] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3194), 1, + ACTIONS(3258), 1, anon_sym_GT, - [58564] = 2, + [60742] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3196), 1, - anon_sym_RBRACK, - [58571] = 2, + ACTIONS(1726), 1, + anon_sym_type, + [60749] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3198), 1, - sym_identifier, - [58578] = 2, + ACTIONS(3260), 1, + anon_sym_RPAREN, + [60756] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3200), 1, + ACTIONS(3262), 1, anon_sym_LBRACE, - [58585] = 2, + [60763] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3202), 1, + ACTIONS(3264), 1, anon_sym_LPAREN, - [58592] = 2, + [60770] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2682), 1, - anon_sym_EQ_GT, - [58599] = 2, + ACTIONS(3266), 1, + sym_identifier, + [60777] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3204), 1, + ACTIONS(3268), 1, anon_sym_LBRACE, - [58606] = 2, + [60784] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1488), 1, - sym__statement_break, - [58613] = 2, + ACTIONS(3270), 1, + anon_sym_EQ_GT, + [60791] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3206), 1, + ACTIONS(3272), 1, sym_identifier, - [58620] = 2, + [60798] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3208), 1, - sym_identifier, - [58627] = 2, + ACTIONS(3274), 1, + anon_sym_LPAREN, + [60805] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3210), 1, - anon_sym_LPAREN, - [58634] = 2, + ACTIONS(1772), 1, + anon_sym_LBRACE, + [60812] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3212), 1, + ACTIONS(3276), 1, sym_identifier, - [58641] = 2, + [60819] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3214), 1, + ACTIONS(3278), 1, anon_sym_QMARK, - [58648] = 2, + [60826] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3216), 1, + ACTIONS(3280), 1, anon_sym_fn, - [58655] = 2, + [60833] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3218), 1, + ACTIONS(3282), 1, anon_sym_effect, - [58662] = 2, + [60840] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3220), 1, + ACTIONS(3284), 1, anon_sym_module, - [58669] = 2, + [60847] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3222), 1, - sym_identifier, - [58676] = 2, + ACTIONS(1510), 1, + sym__statement_break, + [60854] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3224), 1, - anon_sym_COLON, - [58683] = 2, + ACTIONS(1442), 1, + sym__statement_break, + [60861] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1490), 1, - sym__statement_break, - [58690] = 2, + ACTIONS(3286), 1, + sym_identifier, + [60868] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3226), 1, + ACTIONS(3288), 1, anon_sym_fn, - [58697] = 2, + [60875] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3228), 1, + ACTIONS(3290), 1, anon_sym_effect, - [58704] = 2, + [60882] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3230), 1, + ACTIONS(3292), 1, anon_sym_module, - [58711] = 2, + [60889] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1408), 1, - sym__statement_break, - [58718] = 2, + ACTIONS(3294), 1, + sym_identifier, + [60896] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3232), 1, - anon_sym_COLON, - [58725] = 2, + ACTIONS(3296), 1, + anon_sym_LBRACE, + [60903] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3234), 1, + ACTIONS(3298), 1, anon_sym_DOT, - [58732] = 2, + [60910] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3236), 1, - anon_sym_RBRACE, - [58739] = 2, + ACTIONS(3300), 1, + anon_sym_DOT_DOT, + [60917] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3238), 1, + ACTIONS(3302), 1, anon_sym_GT, - [58746] = 2, + [60924] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3240), 1, - anon_sym_GT, - [58753] = 2, + ACTIONS(1512), 1, + sym__statement_break, + [60931] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3242), 1, - anon_sym_EQ_GT, - [58760] = 2, + ACTIONS(3304), 1, + sym_identifier, + [60938] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3244), 1, + ACTIONS(3306), 1, anon_sym_GT, - [58767] = 2, + [60945] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3246), 1, - sym_identifier, - [58774] = 2, + ACTIONS(1572), 1, + sym__statement_break, + [60952] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3248), 1, - anon_sym_LBRACE, - [58781] = 2, + ACTIONS(2716), 1, + anon_sym_EQ_GT, + [60959] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3250), 1, - anon_sym_QMARK, - [58788] = 2, + ACTIONS(1514), 1, + sym__statement_break, + [60966] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3252), 1, - anon_sym_RBRACE, - [58795] = 2, + ACTIONS(3308), 1, + sym_identifier, + [60973] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3254), 1, - anon_sym_RBRACE, - [58802] = 2, + ACTIONS(1516), 1, + sym__statement_break, + [60980] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3256), 1, + ACTIONS(3310), 1, anon_sym_DOT, - [58809] = 2, + [60987] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3258), 1, + ACTIONS(3312), 1, anon_sym_RBRACE, - [58816] = 2, + [60994] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3260), 1, + ACTIONS(3314), 1, anon_sym_LPAREN, - [58823] = 2, + [61001] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3262), 1, - anon_sym_GT, - [58830] = 2, + ACTIONS(1518), 1, + sym__statement_break, + [61008] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3264), 1, - sym_identifier, - [58837] = 2, + ACTIONS(1428), 1, + sym__statement_break, + [61015] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1512), 1, - sym__statement_break, - [58844] = 2, + ACTIONS(3316), 1, + sym_identifier, + [61022] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3266), 1, - anon_sym_LPAREN, - [58851] = 2, + ACTIONS(1430), 1, + sym__statement_break, + [61029] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3268), 1, - anon_sym_RPAREN, - [58858] = 2, + ACTIONS(3318), 1, + sym_identifier, + [61036] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3270), 1, + ACTIONS(3320), 1, anon_sym_LPAREN, - [58865] = 2, + [61043] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1492), 1, - sym__statement_break, - [58872] = 2, + ACTIONS(2433), 1, + anon_sym_RBRACE, + [61050] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3272), 1, + ACTIONS(1524), 1, sym__statement_break, - [58879] = 2, + [61057] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3274), 1, + ACTIONS(3322), 1, anon_sym_RBRACE, - [58886] = 2, + [61064] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3276), 1, - sym__statement_break, - [58893] = 2, + ACTIONS(3324), 1, + anon_sym_GT, + [61071] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3278), 1, - anon_sym_fn, - [58900] = 2, + ACTIONS(3326), 1, + anon_sym_DASH_GT, + [61078] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3280), 1, - anon_sym_LBRACE, + ACTIONS(1484), 1, + sym__statement_break, }; static const uint32_t ts_small_parse_table_map[] = { @@ -53966,1700 +55646,1726 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(28)] = 882, [SMALL_STATE(29)] = 1008, [SMALL_STATE(30)] = 1134, - [SMALL_STATE(31)] = 1251, - [SMALL_STATE(32)] = 1368, - [SMALL_STATE(33)] = 1485, - [SMALL_STATE(34)] = 1602, - [SMALL_STATE(35)] = 1719, - [SMALL_STATE(36)] = 1836, - [SMALL_STATE(37)] = 1953, - [SMALL_STATE(38)] = 2070, - [SMALL_STATE(39)] = 2187, - [SMALL_STATE(40)] = 2304, - [SMALL_STATE(41)] = 2421, - [SMALL_STATE(42)] = 2538, - [SMALL_STATE(43)] = 2655, - [SMALL_STATE(44)] = 2769, - [SMALL_STATE(45)] = 2883, - [SMALL_STATE(46)] = 2997, - [SMALL_STATE(47)] = 3111, - [SMALL_STATE(48)] = 3225, - [SMALL_STATE(49)] = 3339, - [SMALL_STATE(50)] = 3453, - [SMALL_STATE(51)] = 3567, - [SMALL_STATE(52)] = 3681, - [SMALL_STATE(53)] = 3795, - [SMALL_STATE(54)] = 3909, - [SMALL_STATE(55)] = 4023, - [SMALL_STATE(56)] = 4137, - [SMALL_STATE(57)] = 4251, - [SMALL_STATE(58)] = 4365, - [SMALL_STATE(59)] = 4479, - [SMALL_STATE(60)] = 4593, - [SMALL_STATE(61)] = 4707, - [SMALL_STATE(62)] = 4821, - [SMALL_STATE(63)] = 4935, - [SMALL_STATE(64)] = 5049, - [SMALL_STATE(65)] = 5163, - [SMALL_STATE(66)] = 5277, - [SMALL_STATE(67)] = 5391, - [SMALL_STATE(68)] = 5505, - [SMALL_STATE(69)] = 5619, - [SMALL_STATE(70)] = 5733, - [SMALL_STATE(71)] = 5847, - [SMALL_STATE(72)] = 5961, - [SMALL_STATE(73)] = 6075, - [SMALL_STATE(74)] = 6189, - [SMALL_STATE(75)] = 6303, - [SMALL_STATE(76)] = 6417, - [SMALL_STATE(77)] = 6531, - [SMALL_STATE(78)] = 6645, - [SMALL_STATE(79)] = 6761, - [SMALL_STATE(80)] = 6875, - [SMALL_STATE(81)] = 6989, - [SMALL_STATE(82)] = 7103, - [SMALL_STATE(83)] = 7217, - [SMALL_STATE(84)] = 7331, - [SMALL_STATE(85)] = 7445, - [SMALL_STATE(86)] = 7559, - [SMALL_STATE(87)] = 7673, - [SMALL_STATE(88)] = 7787, - [SMALL_STATE(89)] = 7901, - [SMALL_STATE(90)] = 8015, - [SMALL_STATE(91)] = 8129, - [SMALL_STATE(92)] = 8243, - [SMALL_STATE(93)] = 8357, - [SMALL_STATE(94)] = 8471, - [SMALL_STATE(95)] = 8585, - [SMALL_STATE(96)] = 8699, - [SMALL_STATE(97)] = 8813, - [SMALL_STATE(98)] = 8927, - [SMALL_STATE(99)] = 9041, - [SMALL_STATE(100)] = 9155, - [SMALL_STATE(101)] = 9269, - [SMALL_STATE(102)] = 9383, - [SMALL_STATE(103)] = 9497, - [SMALL_STATE(104)] = 9611, - [SMALL_STATE(105)] = 9725, - [SMALL_STATE(106)] = 9839, - [SMALL_STATE(107)] = 9953, - [SMALL_STATE(108)] = 10067, - [SMALL_STATE(109)] = 10181, - [SMALL_STATE(110)] = 10295, - [SMALL_STATE(111)] = 10409, - [SMALL_STATE(112)] = 10523, - [SMALL_STATE(113)] = 10637, - [SMALL_STATE(114)] = 10751, - [SMALL_STATE(115)] = 10865, - [SMALL_STATE(116)] = 10979, - [SMALL_STATE(117)] = 11093, - [SMALL_STATE(118)] = 11207, - [SMALL_STATE(119)] = 11321, - [SMALL_STATE(120)] = 11435, - [SMALL_STATE(121)] = 11549, - [SMALL_STATE(122)] = 11663, - [SMALL_STATE(123)] = 11777, - [SMALL_STATE(124)] = 11891, - [SMALL_STATE(125)] = 12005, - [SMALL_STATE(126)] = 12119, - [SMALL_STATE(127)] = 12233, - [SMALL_STATE(128)] = 12347, - [SMALL_STATE(129)] = 12461, - [SMALL_STATE(130)] = 12575, - [SMALL_STATE(131)] = 12689, - [SMALL_STATE(132)] = 12803, - [SMALL_STATE(133)] = 12917, - [SMALL_STATE(134)] = 13031, - [SMALL_STATE(135)] = 13145, - [SMALL_STATE(136)] = 13259, - [SMALL_STATE(137)] = 13373, - [SMALL_STATE(138)] = 13487, - [SMALL_STATE(139)] = 13601, - [SMALL_STATE(140)] = 13715, - [SMALL_STATE(141)] = 13829, - [SMALL_STATE(142)] = 13943, - [SMALL_STATE(143)] = 14057, - [SMALL_STATE(144)] = 14171, - [SMALL_STATE(145)] = 14285, - [SMALL_STATE(146)] = 14399, - [SMALL_STATE(147)] = 14513, - [SMALL_STATE(148)] = 14627, - [SMALL_STATE(149)] = 14741, - [SMALL_STATE(150)] = 14855, - [SMALL_STATE(151)] = 14969, - [SMALL_STATE(152)] = 15083, - [SMALL_STATE(153)] = 15197, - [SMALL_STATE(154)] = 15311, - [SMALL_STATE(155)] = 15425, - [SMALL_STATE(156)] = 15539, - [SMALL_STATE(157)] = 15653, - [SMALL_STATE(158)] = 15767, - [SMALL_STATE(159)] = 15881, - [SMALL_STATE(160)] = 15995, - [SMALL_STATE(161)] = 16109, - [SMALL_STATE(162)] = 16223, - [SMALL_STATE(163)] = 16337, - [SMALL_STATE(164)] = 16451, - [SMALL_STATE(165)] = 16565, - [SMALL_STATE(166)] = 16679, - [SMALL_STATE(167)] = 16793, - [SMALL_STATE(168)] = 16907, - [SMALL_STATE(169)] = 17021, - [SMALL_STATE(170)] = 17135, - [SMALL_STATE(171)] = 17249, - [SMALL_STATE(172)] = 17363, - [SMALL_STATE(173)] = 17477, - [SMALL_STATE(174)] = 17591, - [SMALL_STATE(175)] = 17705, - [SMALL_STATE(176)] = 17819, - [SMALL_STATE(177)] = 17933, - [SMALL_STATE(178)] = 18047, - [SMALL_STATE(179)] = 18161, - [SMALL_STATE(180)] = 18275, - [SMALL_STATE(181)] = 18389, - [SMALL_STATE(182)] = 18503, - [SMALL_STATE(183)] = 18617, - [SMALL_STATE(184)] = 18731, - [SMALL_STATE(185)] = 18845, - [SMALL_STATE(186)] = 18959, - [SMALL_STATE(187)] = 19073, - [SMALL_STATE(188)] = 19187, - [SMALL_STATE(189)] = 19301, - [SMALL_STATE(190)] = 19415, - [SMALL_STATE(191)] = 19529, - [SMALL_STATE(192)] = 19643, - [SMALL_STATE(193)] = 19757, - [SMALL_STATE(194)] = 19871, - [SMALL_STATE(195)] = 19985, - [SMALL_STATE(196)] = 20099, - [SMALL_STATE(197)] = 20213, - [SMALL_STATE(198)] = 20327, - [SMALL_STATE(199)] = 20441, - [SMALL_STATE(200)] = 20555, - [SMALL_STATE(201)] = 20669, - [SMALL_STATE(202)] = 20783, - [SMALL_STATE(203)] = 20897, - [SMALL_STATE(204)] = 21011, - [SMALL_STATE(205)] = 21125, - [SMALL_STATE(206)] = 21239, - [SMALL_STATE(207)] = 21353, - [SMALL_STATE(208)] = 21467, - [SMALL_STATE(209)] = 21581, - [SMALL_STATE(210)] = 21695, - [SMALL_STATE(211)] = 21809, - [SMALL_STATE(212)] = 21923, - [SMALL_STATE(213)] = 22037, - [SMALL_STATE(214)] = 22151, - [SMALL_STATE(215)] = 22265, - [SMALL_STATE(216)] = 22379, - [SMALL_STATE(217)] = 22493, - [SMALL_STATE(218)] = 22607, - [SMALL_STATE(219)] = 22721, - [SMALL_STATE(220)] = 22835, - [SMALL_STATE(221)] = 22949, - [SMALL_STATE(222)] = 23063, - [SMALL_STATE(223)] = 23177, - [SMALL_STATE(224)] = 23233, - [SMALL_STATE(225)] = 23289, - [SMALL_STATE(226)] = 23337, - [SMALL_STATE(227)] = 23385, - [SMALL_STATE(228)] = 23441, - [SMALL_STATE(229)] = 23490, - [SMALL_STATE(230)] = 23539, - [SMALL_STATE(231)] = 23589, - [SMALL_STATE(232)] = 23633, - [SMALL_STATE(233)] = 23688, - [SMALL_STATE(234)] = 23731, - [SMALL_STATE(235)] = 23800, - [SMALL_STATE(236)] = 23849, - [SMALL_STATE(237)] = 23892, - [SMALL_STATE(238)] = 23961, - [SMALL_STATE(239)] = 24030, - [SMALL_STATE(240)] = 24073, - [SMALL_STATE(241)] = 24116, - [SMALL_STATE(242)] = 24185, - [SMALL_STATE(243)] = 24228, - [SMALL_STATE(244)] = 24271, - [SMALL_STATE(245)] = 24314, - [SMALL_STATE(246)] = 24357, - [SMALL_STATE(247)] = 24400, - [SMALL_STATE(248)] = 24453, - [SMALL_STATE(249)] = 24496, - [SMALL_STATE(250)] = 24539, - [SMALL_STATE(251)] = 24582, - [SMALL_STATE(252)] = 24625, - [SMALL_STATE(253)] = 24676, - [SMALL_STATE(254)] = 24733, - [SMALL_STATE(255)] = 24796, - [SMALL_STATE(256)] = 24857, - [SMALL_STATE(257)] = 24900, - [SMALL_STATE(258)] = 24949, - [SMALL_STATE(259)] = 24992, - [SMALL_STATE(260)] = 25035, - [SMALL_STATE(261)] = 25078, - [SMALL_STATE(262)] = 25147, - [SMALL_STATE(263)] = 25190, - [SMALL_STATE(264)] = 25233, - [SMALL_STATE(265)] = 25302, - [SMALL_STATE(266)] = 25345, - [SMALL_STATE(267)] = 25388, - [SMALL_STATE(268)] = 25431, - [SMALL_STATE(269)] = 25474, - [SMALL_STATE(270)] = 25517, - [SMALL_STATE(271)] = 25560, - [SMALL_STATE(272)] = 25627, - [SMALL_STATE(273)] = 25670, - [SMALL_STATE(274)] = 25713, - [SMALL_STATE(275)] = 25756, - [SMALL_STATE(276)] = 25825, - [SMALL_STATE(277)] = 25868, - [SMALL_STATE(278)] = 25937, - [SMALL_STATE(279)] = 25980, - [SMALL_STATE(280)] = 26023, - [SMALL_STATE(281)] = 26090, - [SMALL_STATE(282)] = 26159, - [SMALL_STATE(283)] = 26228, - [SMALL_STATE(284)] = 26297, - [SMALL_STATE(285)] = 26340, - [SMALL_STATE(286)] = 26383, - [SMALL_STATE(287)] = 26452, - [SMALL_STATE(288)] = 26495, - [SMALL_STATE(289)] = 26564, - [SMALL_STATE(290)] = 26607, - [SMALL_STATE(291)] = 26653, - [SMALL_STATE(292)] = 26699, - [SMALL_STATE(293)] = 26740, - [SMALL_STATE(294)] = 26787, - [SMALL_STATE(295)] = 26851, - [SMALL_STATE(296)] = 26897, - [SMALL_STATE(297)] = 26937, - [SMALL_STATE(298)] = 27001, - [SMALL_STATE(299)] = 27065, - [SMALL_STATE(300)] = 27129, - [SMALL_STATE(301)] = 27193, - [SMALL_STATE(302)] = 27257, - [SMALL_STATE(303)] = 27297, - [SMALL_STATE(304)] = 27337, - [SMALL_STATE(305)] = 27377, - [SMALL_STATE(306)] = 27417, - [SMALL_STATE(307)] = 27481, - [SMALL_STATE(308)] = 27521, - [SMALL_STATE(309)] = 27561, - [SMALL_STATE(310)] = 27609, - [SMALL_STATE(311)] = 27663, - [SMALL_STATE(312)] = 27721, - [SMALL_STATE(313)] = 27777, - [SMALL_STATE(314)] = 27829, - [SMALL_STATE(315)] = 27875, - [SMALL_STATE(316)] = 27915, - [SMALL_STATE(317)] = 27979, - [SMALL_STATE(318)] = 28019, - [SMALL_STATE(319)] = 28059, - [SMALL_STATE(320)] = 28123, - [SMALL_STATE(321)] = 28187, - [SMALL_STATE(322)] = 28227, - [SMALL_STATE(323)] = 28267, - [SMALL_STATE(324)] = 28307, - [SMALL_STATE(325)] = 28347, - [SMALL_STATE(326)] = 28387, - [SMALL_STATE(327)] = 28427, - [SMALL_STATE(328)] = 28489, - [SMALL_STATE(329)] = 28553, - [SMALL_STATE(330)] = 28593, - [SMALL_STATE(331)] = 28633, - [SMALL_STATE(332)] = 28697, - [SMALL_STATE(333)] = 28737, - [SMALL_STATE(334)] = 28801, - [SMALL_STATE(335)] = 28865, - [SMALL_STATE(336)] = 28929, - [SMALL_STATE(337)] = 28969, - [SMALL_STATE(338)] = 29009, - [SMALL_STATE(339)] = 29071, - [SMALL_STATE(340)] = 29135, - [SMALL_STATE(341)] = 29199, - [SMALL_STATE(342)] = 29263, - [SMALL_STATE(343)] = 29303, - [SMALL_STATE(344)] = 29343, - [SMALL_STATE(345)] = 29407, - [SMALL_STATE(346)] = 29447, - [SMALL_STATE(347)] = 29511, - [SMALL_STATE(348)] = 29551, - [SMALL_STATE(349)] = 29591, - [SMALL_STATE(350)] = 29655, - [SMALL_STATE(351)] = 29719, - [SMALL_STATE(352)] = 29759, - [SMALL_STATE(353)] = 29823, - [SMALL_STATE(354)] = 29863, - [SMALL_STATE(355)] = 29903, - [SMALL_STATE(356)] = 29943, - [SMALL_STATE(357)] = 30007, - [SMALL_STATE(358)] = 30071, - [SMALL_STATE(359)] = 30135, - [SMALL_STATE(360)] = 30199, - [SMALL_STATE(361)] = 30263, - [SMALL_STATE(362)] = 30327, - [SMALL_STATE(363)] = 30391, - [SMALL_STATE(364)] = 30455, - [SMALL_STATE(365)] = 30519, - [SMALL_STATE(366)] = 30583, - [SMALL_STATE(367)] = 30647, - [SMALL_STATE(368)] = 30711, - [SMALL_STATE(369)] = 30775, - [SMALL_STATE(370)] = 30839, - [SMALL_STATE(371)] = 30903, - [SMALL_STATE(372)] = 30967, - [SMALL_STATE(373)] = 31031, - [SMALL_STATE(374)] = 31095, - [SMALL_STATE(375)] = 31159, - [SMALL_STATE(376)] = 31223, - [SMALL_STATE(377)] = 31287, - [SMALL_STATE(378)] = 31351, - [SMALL_STATE(379)] = 31415, - [SMALL_STATE(380)] = 31455, - [SMALL_STATE(381)] = 31495, - [SMALL_STATE(382)] = 31535, - [SMALL_STATE(383)] = 31599, - [SMALL_STATE(384)] = 31663, - [SMALL_STATE(385)] = 31727, - [SMALL_STATE(386)] = 31767, - [SMALL_STATE(387)] = 31807, - [SMALL_STATE(388)] = 31871, - [SMALL_STATE(389)] = 31935, - [SMALL_STATE(390)] = 31976, - [SMALL_STATE(391)] = 32016, - [SMALL_STATE(392)] = 32052, - [SMALL_STATE(393)] = 32114, - [SMALL_STATE(394)] = 32176, - [SMALL_STATE(395)] = 32238, - [SMALL_STATE(396)] = 32300, - [SMALL_STATE(397)] = 32362, - [SMALL_STATE(398)] = 32424, - [SMALL_STATE(399)] = 32486, - [SMALL_STATE(400)] = 32548, - [SMALL_STATE(401)] = 32610, - [SMALL_STATE(402)] = 32672, - [SMALL_STATE(403)] = 32734, - [SMALL_STATE(404)] = 32796, - [SMALL_STATE(405)] = 32858, - [SMALL_STATE(406)] = 32920, - [SMALL_STATE(407)] = 32982, - [SMALL_STATE(408)] = 33044, - [SMALL_STATE(409)] = 33106, - [SMALL_STATE(410)] = 33168, - [SMALL_STATE(411)] = 33230, - [SMALL_STATE(412)] = 33292, - [SMALL_STATE(413)] = 33354, - [SMALL_STATE(414)] = 33416, - [SMALL_STATE(415)] = 33478, - [SMALL_STATE(416)] = 33540, - [SMALL_STATE(417)] = 33602, - [SMALL_STATE(418)] = 33664, - [SMALL_STATE(419)] = 33726, - [SMALL_STATE(420)] = 33774, - [SMALL_STATE(421)] = 33836, - [SMALL_STATE(422)] = 33898, - [SMALL_STATE(423)] = 33960, - [SMALL_STATE(424)] = 34022, - [SMALL_STATE(425)] = 34084, - [SMALL_STATE(426)] = 34146, - [SMALL_STATE(427)] = 34189, - [SMALL_STATE(428)] = 34238, - [SMALL_STATE(429)] = 34279, - [SMALL_STATE(430)] = 34324, - [SMALL_STATE(431)] = 34369, - [SMALL_STATE(432)] = 34405, - [SMALL_STATE(433)] = 34441, - [SMALL_STATE(434)] = 34478, - [SMALL_STATE(435)] = 34509, - [SMALL_STATE(436)] = 34564, - [SMALL_STATE(437)] = 34619, - [SMALL_STATE(438)] = 34674, - [SMALL_STATE(439)] = 34709, - [SMALL_STATE(440)] = 34747, - [SMALL_STATE(441)] = 34801, - [SMALL_STATE(442)] = 34831, - [SMALL_STATE(443)] = 34861, - [SMALL_STATE(444)] = 34905, - [SMALL_STATE(445)] = 34953, - [SMALL_STATE(446)] = 34999, - [SMALL_STATE(447)] = 35041, - [SMALL_STATE(448)] = 35077, - [SMALL_STATE(449)] = 35107, - [SMALL_STATE(450)] = 35137, - [SMALL_STATE(451)] = 35191, - [SMALL_STATE(452)] = 35245, - [SMALL_STATE(453)] = 35275, - [SMALL_STATE(454)] = 35305, - [SMALL_STATE(455)] = 35357, - [SMALL_STATE(456)] = 35387, - [SMALL_STATE(457)] = 35417, - [SMALL_STATE(458)] = 35475, - [SMALL_STATE(459)] = 35505, - [SMALL_STATE(460)] = 35559, - [SMALL_STATE(461)] = 35589, - [SMALL_STATE(462)] = 35641, - [SMALL_STATE(463)] = 35671, - [SMALL_STATE(464)] = 35701, - [SMALL_STATE(465)] = 35731, - [SMALL_STATE(466)] = 35761, - [SMALL_STATE(467)] = 35815, - [SMALL_STATE(468)] = 35845, - [SMALL_STATE(469)] = 35875, - [SMALL_STATE(470)] = 35933, - [SMALL_STATE(471)] = 35985, - [SMALL_STATE(472)] = 36021, - [SMALL_STATE(473)] = 36051, - [SMALL_STATE(474)] = 36081, - [SMALL_STATE(475)] = 36111, - [SMALL_STATE(476)] = 36169, - [SMALL_STATE(477)] = 36223, - [SMALL_STATE(478)] = 36253, - [SMALL_STATE(479)] = 36283, - [SMALL_STATE(480)] = 36313, - [SMALL_STATE(481)] = 36343, - [SMALL_STATE(482)] = 36395, - [SMALL_STATE(483)] = 36425, - [SMALL_STATE(484)] = 36479, - [SMALL_STATE(485)] = 36509, - [SMALL_STATE(486)] = 36539, - [SMALL_STATE(487)] = 36591, - [SMALL_STATE(488)] = 36645, - [SMALL_STATE(489)] = 36675, - [SMALL_STATE(490)] = 36705, - [SMALL_STATE(491)] = 36759, - [SMALL_STATE(492)] = 36813, - [SMALL_STATE(493)] = 36867, - [SMALL_STATE(494)] = 36897, - [SMALL_STATE(495)] = 36927, - [SMALL_STATE(496)] = 36981, - [SMALL_STATE(497)] = 37035, - [SMALL_STATE(498)] = 37087, - [SMALL_STATE(499)] = 37117, - [SMALL_STATE(500)] = 37171, - [SMALL_STATE(501)] = 37201, - [SMALL_STATE(502)] = 37231, - [SMALL_STATE(503)] = 37289, - [SMALL_STATE(504)] = 37347, - [SMALL_STATE(505)] = 37399, - [SMALL_STATE(506)] = 37451, - [SMALL_STATE(507)] = 37481, - [SMALL_STATE(508)] = 37535, - [SMALL_STATE(509)] = 37593, - [SMALL_STATE(510)] = 37651, - [SMALL_STATE(511)] = 37703, - [SMALL_STATE(512)] = 37755, - [SMALL_STATE(513)] = 37785, - [SMALL_STATE(514)] = 37839, - [SMALL_STATE(515)] = 37870, - [SMALL_STATE(516)] = 37899, - [SMALL_STATE(517)] = 37952, - [SMALL_STATE(518)] = 38005, - [SMALL_STATE(519)] = 38044, - [SMALL_STATE(520)] = 38097, - [SMALL_STATE(521)] = 38150, - [SMALL_STATE(522)] = 38203, - [SMALL_STATE(523)] = 38258, - [SMALL_STATE(524)] = 38313, - [SMALL_STATE(525)] = 38362, - [SMALL_STATE(526)] = 38415, - [SMALL_STATE(527)] = 38464, - [SMALL_STATE(528)] = 38519, - [SMALL_STATE(529)] = 38574, - [SMALL_STATE(530)] = 38627, - [SMALL_STATE(531)] = 38682, - [SMALL_STATE(532)] = 38711, - [SMALL_STATE(533)] = 38740, - [SMALL_STATE(534)] = 38769, - [SMALL_STATE(535)] = 38824, - [SMALL_STATE(536)] = 38879, - [SMALL_STATE(537)] = 38928, - [SMALL_STATE(538)] = 38957, - [SMALL_STATE(539)] = 39009, - [SMALL_STATE(540)] = 39061, - [SMALL_STATE(541)] = 39113, - [SMALL_STATE(542)] = 39165, - [SMALL_STATE(543)] = 39217, - [SMALL_STATE(544)] = 39269, - [SMALL_STATE(545)] = 39321, - [SMALL_STATE(546)] = 39373, - [SMALL_STATE(547)] = 39421, - [SMALL_STATE(548)] = 39473, - [SMALL_STATE(549)] = 39525, - [SMALL_STATE(550)] = 39577, - [SMALL_STATE(551)] = 39629, - [SMALL_STATE(552)] = 39681, - [SMALL_STATE(553)] = 39733, - [SMALL_STATE(554)] = 39785, - [SMALL_STATE(555)] = 39837, - [SMALL_STATE(556)] = 39889, - [SMALL_STATE(557)] = 39941, - [SMALL_STATE(558)] = 39993, - [SMALL_STATE(559)] = 40045, - [SMALL_STATE(560)] = 40097, - [SMALL_STATE(561)] = 40145, - [SMALL_STATE(562)] = 40177, - [SMALL_STATE(563)] = 40229, - [SMALL_STATE(564)] = 40281, - [SMALL_STATE(565)] = 40333, - [SMALL_STATE(566)] = 40385, - [SMALL_STATE(567)] = 40437, - [SMALL_STATE(568)] = 40485, - [SMALL_STATE(569)] = 40537, - [SMALL_STATE(570)] = 40589, - [SMALL_STATE(571)] = 40641, - [SMALL_STATE(572)] = 40693, - [SMALL_STATE(573)] = 40745, - [SMALL_STATE(574)] = 40797, - [SMALL_STATE(575)] = 40849, - [SMALL_STATE(576)] = 40901, - [SMALL_STATE(577)] = 40953, - [SMALL_STATE(578)] = 41005, - [SMALL_STATE(579)] = 41057, - [SMALL_STATE(580)] = 41109, - [SMALL_STATE(581)] = 41161, - [SMALL_STATE(582)] = 41213, - [SMALL_STATE(583)] = 41265, - [SMALL_STATE(584)] = 41317, - [SMALL_STATE(585)] = 41369, - [SMALL_STATE(586)] = 41421, - [SMALL_STATE(587)] = 41473, - [SMALL_STATE(588)] = 41525, - [SMALL_STATE(589)] = 41577, - [SMALL_STATE(590)] = 41629, - [SMALL_STATE(591)] = 41681, - [SMALL_STATE(592)] = 41733, - [SMALL_STATE(593)] = 41785, - [SMALL_STATE(594)] = 41837, - [SMALL_STATE(595)] = 41889, - [SMALL_STATE(596)] = 41941, - [SMALL_STATE(597)] = 41993, - [SMALL_STATE(598)] = 42045, - [SMALL_STATE(599)] = 42097, - [SMALL_STATE(600)] = 42149, - [SMALL_STATE(601)] = 42201, - [SMALL_STATE(602)] = 42253, - [SMALL_STATE(603)] = 42305, - [SMALL_STATE(604)] = 42357, - [SMALL_STATE(605)] = 42409, - [SMALL_STATE(606)] = 42461, - [SMALL_STATE(607)] = 42513, - [SMALL_STATE(608)] = 42565, - [SMALL_STATE(609)] = 42617, - [SMALL_STATE(610)] = 42669, - [SMALL_STATE(611)] = 42721, - [SMALL_STATE(612)] = 42773, - [SMALL_STATE(613)] = 42825, - [SMALL_STATE(614)] = 42877, - [SMALL_STATE(615)] = 42929, - [SMALL_STATE(616)] = 42956, - [SMALL_STATE(617)] = 43001, - [SMALL_STATE(618)] = 43034, - [SMALL_STATE(619)] = 43067, - [SMALL_STATE(620)] = 43112, - [SMALL_STATE(621)] = 43161, - [SMALL_STATE(622)] = 43210, - [SMALL_STATE(623)] = 43259, - [SMALL_STATE(624)] = 43308, - [SMALL_STATE(625)] = 43357, - [SMALL_STATE(626)] = 43402, - [SMALL_STATE(627)] = 43451, - [SMALL_STATE(628)] = 43500, - [SMALL_STATE(629)] = 43530, - [SMALL_STATE(630)] = 43578, - [SMALL_STATE(631)] = 43626, - [SMALL_STATE(632)] = 43674, - [SMALL_STATE(633)] = 43722, - [SMALL_STATE(634)] = 43770, - [SMALL_STATE(635)] = 43818, - [SMALL_STATE(636)] = 43866, - [SMALL_STATE(637)] = 43914, - [SMALL_STATE(638)] = 43962, - [SMALL_STATE(639)] = 43989, - [SMALL_STATE(640)] = 44015, - [SMALL_STATE(641)] = 44041, - [SMALL_STATE(642)] = 44067, - [SMALL_STATE(643)] = 44088, - [SMALL_STATE(644)] = 44113, - [SMALL_STATE(645)] = 44134, - [SMALL_STATE(646)] = 44159, - [SMALL_STATE(647)] = 44180, - [SMALL_STATE(648)] = 44205, - [SMALL_STATE(649)] = 44230, - [SMALL_STATE(650)] = 44261, - [SMALL_STATE(651)] = 44281, - [SMALL_STATE(652)] = 44301, - [SMALL_STATE(653)] = 44335, - [SMALL_STATE(654)] = 44355, - [SMALL_STATE(655)] = 44389, - [SMALL_STATE(656)] = 44409, - [SMALL_STATE(657)] = 44431, - [SMALL_STATE(658)] = 44453, - [SMALL_STATE(659)] = 44473, - [SMALL_STATE(660)] = 44495, - [SMALL_STATE(661)] = 44515, - [SMALL_STATE(662)] = 44549, - [SMALL_STATE(663)] = 44569, - [SMALL_STATE(664)] = 44603, - [SMALL_STATE(665)] = 44625, - [SMALL_STATE(666)] = 44645, - [SMALL_STATE(667)] = 44679, - [SMALL_STATE(668)] = 44713, - [SMALL_STATE(669)] = 44733, - [SMALL_STATE(670)] = 44753, - [SMALL_STATE(671)] = 44773, - [SMALL_STATE(672)] = 44793, - [SMALL_STATE(673)] = 44813, - [SMALL_STATE(674)] = 44847, - [SMALL_STATE(675)] = 44867, - [SMALL_STATE(676)] = 44887, - [SMALL_STATE(677)] = 44907, - [SMALL_STATE(678)] = 44927, - [SMALL_STATE(679)] = 44947, - [SMALL_STATE(680)] = 44981, - [SMALL_STATE(681)] = 45000, - [SMALL_STATE(682)] = 45019, - [SMALL_STATE(683)] = 45038, - [SMALL_STATE(684)] = 45057, - [SMALL_STATE(685)] = 45076, - [SMALL_STATE(686)] = 45095, - [SMALL_STATE(687)] = 45114, - [SMALL_STATE(688)] = 45133, - [SMALL_STATE(689)] = 45152, - [SMALL_STATE(690)] = 45171, - [SMALL_STATE(691)] = 45190, - [SMALL_STATE(692)] = 45209, - [SMALL_STATE(693)] = 45228, - [SMALL_STATE(694)] = 45247, - [SMALL_STATE(695)] = 45266, - [SMALL_STATE(696)] = 45285, - [SMALL_STATE(697)] = 45310, - [SMALL_STATE(698)] = 45329, - [SMALL_STATE(699)] = 45348, - [SMALL_STATE(700)] = 45367, - [SMALL_STATE(701)] = 45386, - [SMALL_STATE(702)] = 45405, - [SMALL_STATE(703)] = 45424, - [SMALL_STATE(704)] = 45443, - [SMALL_STATE(705)] = 45462, - [SMALL_STATE(706)] = 45481, - [SMALL_STATE(707)] = 45500, - [SMALL_STATE(708)] = 45519, - [SMALL_STATE(709)] = 45538, - [SMALL_STATE(710)] = 45557, - [SMALL_STATE(711)] = 45576, - [SMALL_STATE(712)] = 45595, - [SMALL_STATE(713)] = 45614, - [SMALL_STATE(714)] = 45633, - [SMALL_STATE(715)] = 45652, - [SMALL_STATE(716)] = 45671, - [SMALL_STATE(717)] = 45690, - [SMALL_STATE(718)] = 45709, - [SMALL_STATE(719)] = 45728, - [SMALL_STATE(720)] = 45747, - [SMALL_STATE(721)] = 45766, - [SMALL_STATE(722)] = 45785, - [SMALL_STATE(723)] = 45804, - [SMALL_STATE(724)] = 45823, - [SMALL_STATE(725)] = 45842, - [SMALL_STATE(726)] = 45861, - [SMALL_STATE(727)] = 45880, - [SMALL_STATE(728)] = 45899, - [SMALL_STATE(729)] = 45918, - [SMALL_STATE(730)] = 45937, - [SMALL_STATE(731)] = 45956, - [SMALL_STATE(732)] = 45975, - [SMALL_STATE(733)] = 45994, - [SMALL_STATE(734)] = 46021, - [SMALL_STATE(735)] = 46040, - [SMALL_STATE(736)] = 46059, - [SMALL_STATE(737)] = 46078, - [SMALL_STATE(738)] = 46097, - [SMALL_STATE(739)] = 46116, - [SMALL_STATE(740)] = 46135, - [SMALL_STATE(741)] = 46154, - [SMALL_STATE(742)] = 46173, - [SMALL_STATE(743)] = 46192, - [SMALL_STATE(744)] = 46211, - [SMALL_STATE(745)] = 46230, - [SMALL_STATE(746)] = 46249, - [SMALL_STATE(747)] = 46268, - [SMALL_STATE(748)] = 46287, - [SMALL_STATE(749)] = 46306, - [SMALL_STATE(750)] = 46325, - [SMALL_STATE(751)] = 46344, - [SMALL_STATE(752)] = 46378, - [SMALL_STATE(753)] = 46402, - [SMALL_STATE(754)] = 46436, - [SMALL_STATE(755)] = 46470, - [SMALL_STATE(756)] = 46504, - [SMALL_STATE(757)] = 46538, - [SMALL_STATE(758)] = 46572, - [SMALL_STATE(759)] = 46594, - [SMALL_STATE(760)] = 46628, - [SMALL_STATE(761)] = 46662, - [SMALL_STATE(762)] = 46696, - [SMALL_STATE(763)] = 46730, - [SMALL_STATE(764)] = 46764, - [SMALL_STATE(765)] = 46798, - [SMALL_STATE(766)] = 46832, - [SMALL_STATE(767)] = 46866, - [SMALL_STATE(768)] = 46900, - [SMALL_STATE(769)] = 46934, - [SMALL_STATE(770)] = 46968, - [SMALL_STATE(771)] = 47002, - [SMALL_STATE(772)] = 47036, - [SMALL_STATE(773)] = 47060, - [SMALL_STATE(774)] = 47094, - [SMALL_STATE(775)] = 47128, - [SMALL_STATE(776)] = 47162, - [SMALL_STATE(777)] = 47196, - [SMALL_STATE(778)] = 47230, - [SMALL_STATE(779)] = 47264, - [SMALL_STATE(780)] = 47298, - [SMALL_STATE(781)] = 47332, - [SMALL_STATE(782)] = 47356, - [SMALL_STATE(783)] = 47390, - [SMALL_STATE(784)] = 47424, - [SMALL_STATE(785)] = 47458, - [SMALL_STATE(786)] = 47492, - [SMALL_STATE(787)] = 47526, - [SMALL_STATE(788)] = 47548, - [SMALL_STATE(789)] = 47572, - [SMALL_STATE(790)] = 47606, - [SMALL_STATE(791)] = 47625, - [SMALL_STATE(792)] = 47646, - [SMALL_STATE(793)] = 47667, - [SMALL_STATE(794)] = 47686, - [SMALL_STATE(795)] = 47707, - [SMALL_STATE(796)] = 47742, - [SMALL_STATE(797)] = 47761, - [SMALL_STATE(798)] = 47782, - [SMALL_STATE(799)] = 47803, - [SMALL_STATE(800)] = 47832, - [SMALL_STATE(801)] = 47851, - [SMALL_STATE(802)] = 47880, - [SMALL_STATE(803)] = 47909, - [SMALL_STATE(804)] = 47938, - [SMALL_STATE(805)] = 47967, - [SMALL_STATE(806)] = 47988, - [SMALL_STATE(807)] = 48007, - [SMALL_STATE(808)] = 48036, - [SMALL_STATE(809)] = 48057, - [SMALL_STATE(810)] = 48083, - [SMALL_STATE(811)] = 48111, - [SMALL_STATE(812)] = 48137, - [SMALL_STATE(813)] = 48155, - [SMALL_STATE(814)] = 48189, - [SMALL_STATE(815)] = 48207, - [SMALL_STATE(816)] = 48233, - [SMALL_STATE(817)] = 48259, - [SMALL_STATE(818)] = 48285, - [SMALL_STATE(819)] = 48311, - [SMALL_STATE(820)] = 48337, - [SMALL_STATE(821)] = 48369, - [SMALL_STATE(822)] = 48395, - [SMALL_STATE(823)] = 48413, - [SMALL_STATE(824)] = 48436, - [SMALL_STATE(825)] = 48459, - [SMALL_STATE(826)] = 48482, - [SMALL_STATE(827)] = 48497, - [SMALL_STATE(828)] = 48512, - [SMALL_STATE(829)] = 48535, - [SMALL_STATE(830)] = 48558, - [SMALL_STATE(831)] = 48581, - [SMALL_STATE(832)] = 48604, - [SMALL_STATE(833)] = 48619, - [SMALL_STATE(834)] = 48642, - [SMALL_STATE(835)] = 48665, - [SMALL_STATE(836)] = 48680, - [SMALL_STATE(837)] = 48703, - [SMALL_STATE(838)] = 48726, - [SMALL_STATE(839)] = 48749, - [SMALL_STATE(840)] = 48772, - [SMALL_STATE(841)] = 48795, - [SMALL_STATE(842)] = 48818, - [SMALL_STATE(843)] = 48841, - [SMALL_STATE(844)] = 48864, - [SMALL_STATE(845)] = 48887, - [SMALL_STATE(846)] = 48910, - [SMALL_STATE(847)] = 48933, - [SMALL_STATE(848)] = 48952, - [SMALL_STATE(849)] = 48975, - [SMALL_STATE(850)] = 48994, - [SMALL_STATE(851)] = 49017, - [SMALL_STATE(852)] = 49032, - [SMALL_STATE(853)] = 49047, - [SMALL_STATE(854)] = 49062, - [SMALL_STATE(855)] = 49089, - [SMALL_STATE(856)] = 49112, - [SMALL_STATE(857)] = 49127, - [SMALL_STATE(858)] = 49142, - [SMALL_STATE(859)] = 49165, - [SMALL_STATE(860)] = 49180, - [SMALL_STATE(861)] = 49203, - [SMALL_STATE(862)] = 49226, - [SMALL_STATE(863)] = 49249, - [SMALL_STATE(864)] = 49272, - [SMALL_STATE(865)] = 49295, - [SMALL_STATE(866)] = 49318, - [SMALL_STATE(867)] = 49333, - [SMALL_STATE(868)] = 49348, - [SMALL_STATE(869)] = 49371, - [SMALL_STATE(870)] = 49394, - [SMALL_STATE(871)] = 49417, - [SMALL_STATE(872)] = 49440, - [SMALL_STATE(873)] = 49463, - [SMALL_STATE(874)] = 49486, - [SMALL_STATE(875)] = 49509, - [SMALL_STATE(876)] = 49524, - [SMALL_STATE(877)] = 49539, - [SMALL_STATE(878)] = 49562, - [SMALL_STATE(879)] = 49585, - [SMALL_STATE(880)] = 49608, - [SMALL_STATE(881)] = 49631, - [SMALL_STATE(882)] = 49654, - [SMALL_STATE(883)] = 49677, - [SMALL_STATE(884)] = 49700, - [SMALL_STATE(885)] = 49723, - [SMALL_STATE(886)] = 49746, - [SMALL_STATE(887)] = 49769, - [SMALL_STATE(888)] = 49784, - [SMALL_STATE(889)] = 49807, - [SMALL_STATE(890)] = 49822, - [SMALL_STATE(891)] = 49845, - [SMALL_STATE(892)] = 49860, - [SMALL_STATE(893)] = 49883, - [SMALL_STATE(894)] = 49906, - [SMALL_STATE(895)] = 49929, - [SMALL_STATE(896)] = 49952, - [SMALL_STATE(897)] = 49975, - [SMALL_STATE(898)] = 49998, - [SMALL_STATE(899)] = 50021, - [SMALL_STATE(900)] = 50044, - [SMALL_STATE(901)] = 50067, - [SMALL_STATE(902)] = 50090, - [SMALL_STATE(903)] = 50113, - [SMALL_STATE(904)] = 50136, - [SMALL_STATE(905)] = 50159, - [SMALL_STATE(906)] = 50182, - [SMALL_STATE(907)] = 50205, - [SMALL_STATE(908)] = 50228, - [SMALL_STATE(909)] = 50243, - [SMALL_STATE(910)] = 50266, - [SMALL_STATE(911)] = 50289, - [SMALL_STATE(912)] = 50312, - [SMALL_STATE(913)] = 50335, - [SMALL_STATE(914)] = 50358, - [SMALL_STATE(915)] = 50381, - [SMALL_STATE(916)] = 50404, - [SMALL_STATE(917)] = 50427, - [SMALL_STATE(918)] = 50442, - [SMALL_STATE(919)] = 50465, - [SMALL_STATE(920)] = 50488, - [SMALL_STATE(921)] = 50503, - [SMALL_STATE(922)] = 50525, - [SMALL_STATE(923)] = 50539, - [SMALL_STATE(924)] = 50554, - [SMALL_STATE(925)] = 50569, - [SMALL_STATE(926)] = 50584, - [SMALL_STATE(927)] = 50599, - [SMALL_STATE(928)] = 50620, - [SMALL_STATE(929)] = 50635, - [SMALL_STATE(930)] = 50658, - [SMALL_STATE(931)] = 50681, - [SMALL_STATE(932)] = 50696, - [SMALL_STATE(933)] = 50719, - [SMALL_STATE(934)] = 50734, - [SMALL_STATE(935)] = 50755, - [SMALL_STATE(936)] = 50776, - [SMALL_STATE(937)] = 50797, - [SMALL_STATE(938)] = 50820, - [SMALL_STATE(939)] = 50843, - [SMALL_STATE(940)] = 50858, - [SMALL_STATE(941)] = 50873, - [SMALL_STATE(942)] = 50896, - [SMALL_STATE(943)] = 50911, - [SMALL_STATE(944)] = 50926, - [SMALL_STATE(945)] = 50941, - [SMALL_STATE(946)] = 50956, - [SMALL_STATE(947)] = 50971, - [SMALL_STATE(948)] = 50992, - [SMALL_STATE(949)] = 51013, - [SMALL_STATE(950)] = 51034, - [SMALL_STATE(951)] = 51049, - [SMALL_STATE(952)] = 51064, - [SMALL_STATE(953)] = 51085, - [SMALL_STATE(954)] = 51107, - [SMALL_STATE(955)] = 51129, - [SMALL_STATE(956)] = 51149, - [SMALL_STATE(957)] = 51171, - [SMALL_STATE(958)] = 51193, - [SMALL_STATE(959)] = 51215, - [SMALL_STATE(960)] = 51237, - [SMALL_STATE(961)] = 51259, - [SMALL_STATE(962)] = 51281, - [SMALL_STATE(963)] = 51293, - [SMALL_STATE(964)] = 51311, - [SMALL_STATE(965)] = 51333, - [SMALL_STATE(966)] = 51349, - [SMALL_STATE(967)] = 51371, - [SMALL_STATE(968)] = 51385, - [SMALL_STATE(969)] = 51407, - [SMALL_STATE(970)] = 51429, - [SMALL_STATE(971)] = 51451, - [SMALL_STATE(972)] = 51473, - [SMALL_STATE(973)] = 51495, - [SMALL_STATE(974)] = 51517, - [SMALL_STATE(975)] = 51534, - [SMALL_STATE(976)] = 51553, - [SMALL_STATE(977)] = 51572, - [SMALL_STATE(978)] = 51591, - [SMALL_STATE(979)] = 51610, - [SMALL_STATE(980)] = 51627, - [SMALL_STATE(981)] = 51644, - [SMALL_STATE(982)] = 51663, - [SMALL_STATE(983)] = 51678, - [SMALL_STATE(984)] = 51697, - [SMALL_STATE(985)] = 51714, - [SMALL_STATE(986)] = 51731, - [SMALL_STATE(987)] = 51748, - [SMALL_STATE(988)] = 51765, - [SMALL_STATE(989)] = 51782, - [SMALL_STATE(990)] = 51799, - [SMALL_STATE(991)] = 51818, - [SMALL_STATE(992)] = 51837, - [SMALL_STATE(993)] = 51854, - [SMALL_STATE(994)] = 51871, - [SMALL_STATE(995)] = 51888, - [SMALL_STATE(996)] = 51905, - [SMALL_STATE(997)] = 51922, - [SMALL_STATE(998)] = 51941, - [SMALL_STATE(999)] = 51958, - [SMALL_STATE(1000)] = 51975, - [SMALL_STATE(1001)] = 51992, - [SMALL_STATE(1002)] = 52009, - [SMALL_STATE(1003)] = 52026, - [SMALL_STATE(1004)] = 52043, - [SMALL_STATE(1005)] = 52062, - [SMALL_STATE(1006)] = 52079, - [SMALL_STATE(1007)] = 52096, - [SMALL_STATE(1008)] = 52113, - [SMALL_STATE(1009)] = 52130, - [SMALL_STATE(1010)] = 52149, - [SMALL_STATE(1011)] = 52164, - [SMALL_STATE(1012)] = 52181, - [SMALL_STATE(1013)] = 52198, - [SMALL_STATE(1014)] = 52215, - [SMALL_STATE(1015)] = 52232, - [SMALL_STATE(1016)] = 52251, - [SMALL_STATE(1017)] = 52270, - [SMALL_STATE(1018)] = 52287, - [SMALL_STATE(1019)] = 52306, - [SMALL_STATE(1020)] = 52325, - [SMALL_STATE(1021)] = 52342, - [SMALL_STATE(1022)] = 52361, - [SMALL_STATE(1023)] = 52380, - [SMALL_STATE(1024)] = 52397, - [SMALL_STATE(1025)] = 52414, - [SMALL_STATE(1026)] = 52431, - [SMALL_STATE(1027)] = 52448, - [SMALL_STATE(1028)] = 52467, - [SMALL_STATE(1029)] = 52486, - [SMALL_STATE(1030)] = 52503, - [SMALL_STATE(1031)] = 52522, - [SMALL_STATE(1032)] = 52539, - [SMALL_STATE(1033)] = 52556, - [SMALL_STATE(1034)] = 52575, - [SMALL_STATE(1035)] = 52594, - [SMALL_STATE(1036)] = 52611, - [SMALL_STATE(1037)] = 52628, - [SMALL_STATE(1038)] = 52645, - [SMALL_STATE(1039)] = 52662, - [SMALL_STATE(1040)] = 52678, - [SMALL_STATE(1041)] = 52692, - [SMALL_STATE(1042)] = 52706, - [SMALL_STATE(1043)] = 52720, - [SMALL_STATE(1044)] = 52730, - [SMALL_STATE(1045)] = 52744, - [SMALL_STATE(1046)] = 52758, - [SMALL_STATE(1047)] = 52774, - [SMALL_STATE(1048)] = 52784, - [SMALL_STATE(1049)] = 52798, - [SMALL_STATE(1050)] = 52812, - [SMALL_STATE(1051)] = 52826, - [SMALL_STATE(1052)] = 52836, - [SMALL_STATE(1053)] = 52846, - [SMALL_STATE(1054)] = 52860, - [SMALL_STATE(1055)] = 52876, - [SMALL_STATE(1056)] = 52890, - [SMALL_STATE(1057)] = 52906, - [SMALL_STATE(1058)] = 52916, - [SMALL_STATE(1059)] = 52932, - [SMALL_STATE(1060)] = 52942, - [SMALL_STATE(1061)] = 52956, - [SMALL_STATE(1062)] = 52972, - [SMALL_STATE(1063)] = 52986, - [SMALL_STATE(1064)] = 53000, - [SMALL_STATE(1065)] = 53014, - [SMALL_STATE(1066)] = 53030, - [SMALL_STATE(1067)] = 53044, - [SMALL_STATE(1068)] = 53054, - [SMALL_STATE(1069)] = 53068, - [SMALL_STATE(1070)] = 53080, - [SMALL_STATE(1071)] = 53096, - [SMALL_STATE(1072)] = 53106, - [SMALL_STATE(1073)] = 53116, - [SMALL_STATE(1074)] = 53132, - [SMALL_STATE(1075)] = 53146, - [SMALL_STATE(1076)] = 53160, - [SMALL_STATE(1077)] = 53174, - [SMALL_STATE(1078)] = 53190, - [SMALL_STATE(1079)] = 53206, - [SMALL_STATE(1080)] = 53220, - [SMALL_STATE(1081)] = 53234, - [SMALL_STATE(1082)] = 53244, - [SMALL_STATE(1083)] = 53258, - [SMALL_STATE(1084)] = 53268, - [SMALL_STATE(1085)] = 53282, - [SMALL_STATE(1086)] = 53298, - [SMALL_STATE(1087)] = 53312, - [SMALL_STATE(1088)] = 53326, - [SMALL_STATE(1089)] = 53340, - [SMALL_STATE(1090)] = 53354, - [SMALL_STATE(1091)] = 53368, - [SMALL_STATE(1092)] = 53378, - [SMALL_STATE(1093)] = 53392, - [SMALL_STATE(1094)] = 53408, - [SMALL_STATE(1095)] = 53422, - [SMALL_STATE(1096)] = 53436, - [SMALL_STATE(1097)] = 53446, - [SMALL_STATE(1098)] = 53456, - [SMALL_STATE(1099)] = 53466, - [SMALL_STATE(1100)] = 53482, - [SMALL_STATE(1101)] = 53492, - [SMALL_STATE(1102)] = 53506, - [SMALL_STATE(1103)] = 53519, - [SMALL_STATE(1104)] = 53532, - [SMALL_STATE(1105)] = 53545, - [SMALL_STATE(1106)] = 53558, - [SMALL_STATE(1107)] = 53571, - [SMALL_STATE(1108)] = 53582, - [SMALL_STATE(1109)] = 53595, - [SMALL_STATE(1110)] = 53608, - [SMALL_STATE(1111)] = 53621, - [SMALL_STATE(1112)] = 53634, - [SMALL_STATE(1113)] = 53647, - [SMALL_STATE(1114)] = 53660, - [SMALL_STATE(1115)] = 53673, - [SMALL_STATE(1116)] = 53686, - [SMALL_STATE(1117)] = 53699, - [SMALL_STATE(1118)] = 53712, - [SMALL_STATE(1119)] = 53725, - [SMALL_STATE(1120)] = 53738, - [SMALL_STATE(1121)] = 53751, - [SMALL_STATE(1122)] = 53764, - [SMALL_STATE(1123)] = 53777, - [SMALL_STATE(1124)] = 53790, - [SMALL_STATE(1125)] = 53803, - [SMALL_STATE(1126)] = 53816, - [SMALL_STATE(1127)] = 53825, - [SMALL_STATE(1128)] = 53838, - [SMALL_STATE(1129)] = 53851, - [SMALL_STATE(1130)] = 53864, - [SMALL_STATE(1131)] = 53877, - [SMALL_STATE(1132)] = 53890, - [SMALL_STATE(1133)] = 53903, - [SMALL_STATE(1134)] = 53916, - [SMALL_STATE(1135)] = 53927, - [SMALL_STATE(1136)] = 53940, - [SMALL_STATE(1137)] = 53953, - [SMALL_STATE(1138)] = 53966, - [SMALL_STATE(1139)] = 53979, - [SMALL_STATE(1140)] = 53992, - [SMALL_STATE(1141)] = 54005, - [SMALL_STATE(1142)] = 54018, - [SMALL_STATE(1143)] = 54031, - [SMALL_STATE(1144)] = 54044, - [SMALL_STATE(1145)] = 54053, - [SMALL_STATE(1146)] = 54066, - [SMALL_STATE(1147)] = 54079, - [SMALL_STATE(1148)] = 54092, - [SMALL_STATE(1149)] = 54105, - [SMALL_STATE(1150)] = 54118, - [SMALL_STATE(1151)] = 54131, - [SMALL_STATE(1152)] = 54144, - [SMALL_STATE(1153)] = 54157, - [SMALL_STATE(1154)] = 54170, - [SMALL_STATE(1155)] = 54183, - [SMALL_STATE(1156)] = 54192, - [SMALL_STATE(1157)] = 54205, - [SMALL_STATE(1158)] = 54218, - [SMALL_STATE(1159)] = 54227, - [SMALL_STATE(1160)] = 54236, - [SMALL_STATE(1161)] = 54249, - [SMALL_STATE(1162)] = 54262, - [SMALL_STATE(1163)] = 54275, - [SMALL_STATE(1164)] = 54288, - [SMALL_STATE(1165)] = 54299, - [SMALL_STATE(1166)] = 54312, - [SMALL_STATE(1167)] = 54325, - [SMALL_STATE(1168)] = 54338, - [SMALL_STATE(1169)] = 54351, - [SMALL_STATE(1170)] = 54364, - [SMALL_STATE(1171)] = 54377, - [SMALL_STATE(1172)] = 54390, - [SMALL_STATE(1173)] = 54403, - [SMALL_STATE(1174)] = 54416, - [SMALL_STATE(1175)] = 54427, - [SMALL_STATE(1176)] = 54440, - [SMALL_STATE(1177)] = 54449, - [SMALL_STATE(1178)] = 54462, - [SMALL_STATE(1179)] = 54475, - [SMALL_STATE(1180)] = 54488, - [SMALL_STATE(1181)] = 54501, - [SMALL_STATE(1182)] = 54514, - [SMALL_STATE(1183)] = 54527, - [SMALL_STATE(1184)] = 54540, - [SMALL_STATE(1185)] = 54553, - [SMALL_STATE(1186)] = 54566, - [SMALL_STATE(1187)] = 54579, - [SMALL_STATE(1188)] = 54592, - [SMALL_STATE(1189)] = 54605, - [SMALL_STATE(1190)] = 54618, - [SMALL_STATE(1191)] = 54631, - [SMALL_STATE(1192)] = 54644, - [SMALL_STATE(1193)] = 54657, - [SMALL_STATE(1194)] = 54670, - [SMALL_STATE(1195)] = 54683, - [SMALL_STATE(1196)] = 54696, - [SMALL_STATE(1197)] = 54707, - [SMALL_STATE(1198)] = 54720, - [SMALL_STATE(1199)] = 54733, - [SMALL_STATE(1200)] = 54746, - [SMALL_STATE(1201)] = 54759, - [SMALL_STATE(1202)] = 54772, - [SMALL_STATE(1203)] = 54785, - [SMALL_STATE(1204)] = 54798, - [SMALL_STATE(1205)] = 54811, - [SMALL_STATE(1206)] = 54822, - [SMALL_STATE(1207)] = 54833, - [SMALL_STATE(1208)] = 54846, - [SMALL_STATE(1209)] = 54859, - [SMALL_STATE(1210)] = 54872, - [SMALL_STATE(1211)] = 54885, - [SMALL_STATE(1212)] = 54896, - [SMALL_STATE(1213)] = 54909, - [SMALL_STATE(1214)] = 54922, - [SMALL_STATE(1215)] = 54935, - [SMALL_STATE(1216)] = 54948, - [SMALL_STATE(1217)] = 54959, - [SMALL_STATE(1218)] = 54972, - [SMALL_STATE(1219)] = 54985, - [SMALL_STATE(1220)] = 54998, - [SMALL_STATE(1221)] = 55011, - [SMALL_STATE(1222)] = 55022, - [SMALL_STATE(1223)] = 55035, - [SMALL_STATE(1224)] = 55048, - [SMALL_STATE(1225)] = 55061, - [SMALL_STATE(1226)] = 55074, - [SMALL_STATE(1227)] = 55085, - [SMALL_STATE(1228)] = 55098, - [SMALL_STATE(1229)] = 55109, - [SMALL_STATE(1230)] = 55122, - [SMALL_STATE(1231)] = 55135, - [SMALL_STATE(1232)] = 55146, - [SMALL_STATE(1233)] = 55159, - [SMALL_STATE(1234)] = 55172, - [SMALL_STATE(1235)] = 55183, - [SMALL_STATE(1236)] = 55196, - [SMALL_STATE(1237)] = 55209, - [SMALL_STATE(1238)] = 55218, - [SMALL_STATE(1239)] = 55227, - [SMALL_STATE(1240)] = 55240, - [SMALL_STATE(1241)] = 55253, - [SMALL_STATE(1242)] = 55266, - [SMALL_STATE(1243)] = 55279, - [SMALL_STATE(1244)] = 55292, - [SMALL_STATE(1245)] = 55305, - [SMALL_STATE(1246)] = 55318, - [SMALL_STATE(1247)] = 55326, - [SMALL_STATE(1248)] = 55336, - [SMALL_STATE(1249)] = 55346, - [SMALL_STATE(1250)] = 55356, - [SMALL_STATE(1251)] = 55364, - [SMALL_STATE(1252)] = 55372, - [SMALL_STATE(1253)] = 55380, - [SMALL_STATE(1254)] = 55388, - [SMALL_STATE(1255)] = 55398, - [SMALL_STATE(1256)] = 55406, - [SMALL_STATE(1257)] = 55416, - [SMALL_STATE(1258)] = 55426, - [SMALL_STATE(1259)] = 55436, - [SMALL_STATE(1260)] = 55444, - [SMALL_STATE(1261)] = 55454, - [SMALL_STATE(1262)] = 55462, - [SMALL_STATE(1263)] = 55472, - [SMALL_STATE(1264)] = 55480, - [SMALL_STATE(1265)] = 55490, - [SMALL_STATE(1266)] = 55500, - [SMALL_STATE(1267)] = 55510, - [SMALL_STATE(1268)] = 55520, - [SMALL_STATE(1269)] = 55530, - [SMALL_STATE(1270)] = 55540, - [SMALL_STATE(1271)] = 55550, - [SMALL_STATE(1272)] = 55560, - [SMALL_STATE(1273)] = 55570, - [SMALL_STATE(1274)] = 55580, - [SMALL_STATE(1275)] = 55590, - [SMALL_STATE(1276)] = 55598, - [SMALL_STATE(1277)] = 55608, - [SMALL_STATE(1278)] = 55618, - [SMALL_STATE(1279)] = 55628, - [SMALL_STATE(1280)] = 55636, - [SMALL_STATE(1281)] = 55646, - [SMALL_STATE(1282)] = 55656, - [SMALL_STATE(1283)] = 55666, - [SMALL_STATE(1284)] = 55676, - [SMALL_STATE(1285)] = 55686, - [SMALL_STATE(1286)] = 55696, - [SMALL_STATE(1287)] = 55706, - [SMALL_STATE(1288)] = 55714, - [SMALL_STATE(1289)] = 55722, - [SMALL_STATE(1290)] = 55732, - [SMALL_STATE(1291)] = 55742, - [SMALL_STATE(1292)] = 55752, - [SMALL_STATE(1293)] = 55762, - [SMALL_STATE(1294)] = 55772, - [SMALL_STATE(1295)] = 55780, - [SMALL_STATE(1296)] = 55788, - [SMALL_STATE(1297)] = 55796, - [SMALL_STATE(1298)] = 55806, - [SMALL_STATE(1299)] = 55816, - [SMALL_STATE(1300)] = 55826, - [SMALL_STATE(1301)] = 55834, - [SMALL_STATE(1302)] = 55842, - [SMALL_STATE(1303)] = 55850, - [SMALL_STATE(1304)] = 55860, - [SMALL_STATE(1305)] = 55870, - [SMALL_STATE(1306)] = 55880, - [SMALL_STATE(1307)] = 55890, - [SMALL_STATE(1308)] = 55900, - [SMALL_STATE(1309)] = 55908, - [SMALL_STATE(1310)] = 55916, - [SMALL_STATE(1311)] = 55926, - [SMALL_STATE(1312)] = 55936, - [SMALL_STATE(1313)] = 55944, - [SMALL_STATE(1314)] = 55952, - [SMALL_STATE(1315)] = 55962, - [SMALL_STATE(1316)] = 55972, - [SMALL_STATE(1317)] = 55982, - [SMALL_STATE(1318)] = 55992, - [SMALL_STATE(1319)] = 56002, - [SMALL_STATE(1320)] = 56012, - [SMALL_STATE(1321)] = 56020, - [SMALL_STATE(1322)] = 56030, - [SMALL_STATE(1323)] = 56040, - [SMALL_STATE(1324)] = 56048, - [SMALL_STATE(1325)] = 56058, - [SMALL_STATE(1326)] = 56068, - [SMALL_STATE(1327)] = 56078, - [SMALL_STATE(1328)] = 56088, - [SMALL_STATE(1329)] = 56096, - [SMALL_STATE(1330)] = 56106, - [SMALL_STATE(1331)] = 56116, - [SMALL_STATE(1332)] = 56126, - [SMALL_STATE(1333)] = 56136, - [SMALL_STATE(1334)] = 56144, - [SMALL_STATE(1335)] = 56154, - [SMALL_STATE(1336)] = 56162, - [SMALL_STATE(1337)] = 56172, - [SMALL_STATE(1338)] = 56182, - [SMALL_STATE(1339)] = 56192, - [SMALL_STATE(1340)] = 56202, - [SMALL_STATE(1341)] = 56212, - [SMALL_STATE(1342)] = 56222, - [SMALL_STATE(1343)] = 56232, - [SMALL_STATE(1344)] = 56240, - [SMALL_STATE(1345)] = 56247, - [SMALL_STATE(1346)] = 56254, - [SMALL_STATE(1347)] = 56261, - [SMALL_STATE(1348)] = 56268, - [SMALL_STATE(1349)] = 56275, - [SMALL_STATE(1350)] = 56282, - [SMALL_STATE(1351)] = 56289, - [SMALL_STATE(1352)] = 56296, - [SMALL_STATE(1353)] = 56303, - [SMALL_STATE(1354)] = 56310, - [SMALL_STATE(1355)] = 56317, - [SMALL_STATE(1356)] = 56324, - [SMALL_STATE(1357)] = 56331, - [SMALL_STATE(1358)] = 56338, - [SMALL_STATE(1359)] = 56345, - [SMALL_STATE(1360)] = 56352, - [SMALL_STATE(1361)] = 56359, - [SMALL_STATE(1362)] = 56366, - [SMALL_STATE(1363)] = 56373, - [SMALL_STATE(1364)] = 56380, - [SMALL_STATE(1365)] = 56387, - [SMALL_STATE(1366)] = 56394, - [SMALL_STATE(1367)] = 56401, - [SMALL_STATE(1368)] = 56408, - [SMALL_STATE(1369)] = 56415, - [SMALL_STATE(1370)] = 56422, - [SMALL_STATE(1371)] = 56429, - [SMALL_STATE(1372)] = 56436, - [SMALL_STATE(1373)] = 56443, - [SMALL_STATE(1374)] = 56450, - [SMALL_STATE(1375)] = 56457, - [SMALL_STATE(1376)] = 56464, - [SMALL_STATE(1377)] = 56471, - [SMALL_STATE(1378)] = 56478, - [SMALL_STATE(1379)] = 56485, - [SMALL_STATE(1380)] = 56492, - [SMALL_STATE(1381)] = 56499, - [SMALL_STATE(1382)] = 56506, - [SMALL_STATE(1383)] = 56513, - [SMALL_STATE(1384)] = 56520, - [SMALL_STATE(1385)] = 56527, - [SMALL_STATE(1386)] = 56534, - [SMALL_STATE(1387)] = 56541, - [SMALL_STATE(1388)] = 56548, - [SMALL_STATE(1389)] = 56555, - [SMALL_STATE(1390)] = 56562, - [SMALL_STATE(1391)] = 56569, - [SMALL_STATE(1392)] = 56576, - [SMALL_STATE(1393)] = 56583, - [SMALL_STATE(1394)] = 56590, - [SMALL_STATE(1395)] = 56597, - [SMALL_STATE(1396)] = 56604, - [SMALL_STATE(1397)] = 56611, - [SMALL_STATE(1398)] = 56618, - [SMALL_STATE(1399)] = 56625, - [SMALL_STATE(1400)] = 56632, - [SMALL_STATE(1401)] = 56639, - [SMALL_STATE(1402)] = 56646, - [SMALL_STATE(1403)] = 56653, - [SMALL_STATE(1404)] = 56660, - [SMALL_STATE(1405)] = 56667, - [SMALL_STATE(1406)] = 56674, - [SMALL_STATE(1407)] = 56681, - [SMALL_STATE(1408)] = 56688, - [SMALL_STATE(1409)] = 56695, - [SMALL_STATE(1410)] = 56702, - [SMALL_STATE(1411)] = 56709, - [SMALL_STATE(1412)] = 56716, - [SMALL_STATE(1413)] = 56723, - [SMALL_STATE(1414)] = 56730, - [SMALL_STATE(1415)] = 56737, - [SMALL_STATE(1416)] = 56744, - [SMALL_STATE(1417)] = 56751, - [SMALL_STATE(1418)] = 56758, - [SMALL_STATE(1419)] = 56765, - [SMALL_STATE(1420)] = 56772, - [SMALL_STATE(1421)] = 56779, - [SMALL_STATE(1422)] = 56786, - [SMALL_STATE(1423)] = 56793, - [SMALL_STATE(1424)] = 56800, - [SMALL_STATE(1425)] = 56807, - [SMALL_STATE(1426)] = 56814, - [SMALL_STATE(1427)] = 56821, - [SMALL_STATE(1428)] = 56828, - [SMALL_STATE(1429)] = 56835, - [SMALL_STATE(1430)] = 56842, - [SMALL_STATE(1431)] = 56849, - [SMALL_STATE(1432)] = 56856, - [SMALL_STATE(1433)] = 56863, - [SMALL_STATE(1434)] = 56870, - [SMALL_STATE(1435)] = 56877, - [SMALL_STATE(1436)] = 56884, - [SMALL_STATE(1437)] = 56891, - [SMALL_STATE(1438)] = 56898, - [SMALL_STATE(1439)] = 56905, - [SMALL_STATE(1440)] = 56912, - [SMALL_STATE(1441)] = 56919, - [SMALL_STATE(1442)] = 56926, - [SMALL_STATE(1443)] = 56933, - [SMALL_STATE(1444)] = 56940, - [SMALL_STATE(1445)] = 56947, - [SMALL_STATE(1446)] = 56954, - [SMALL_STATE(1447)] = 56961, - [SMALL_STATE(1448)] = 56968, - [SMALL_STATE(1449)] = 56975, - [SMALL_STATE(1450)] = 56982, - [SMALL_STATE(1451)] = 56989, - [SMALL_STATE(1452)] = 56996, - [SMALL_STATE(1453)] = 57003, - [SMALL_STATE(1454)] = 57010, - [SMALL_STATE(1455)] = 57017, - [SMALL_STATE(1456)] = 57024, - [SMALL_STATE(1457)] = 57031, - [SMALL_STATE(1458)] = 57038, - [SMALL_STATE(1459)] = 57045, - [SMALL_STATE(1460)] = 57052, - [SMALL_STATE(1461)] = 57059, - [SMALL_STATE(1462)] = 57066, - [SMALL_STATE(1463)] = 57073, - [SMALL_STATE(1464)] = 57080, - [SMALL_STATE(1465)] = 57087, - [SMALL_STATE(1466)] = 57094, - [SMALL_STATE(1467)] = 57101, - [SMALL_STATE(1468)] = 57108, - [SMALL_STATE(1469)] = 57115, - [SMALL_STATE(1470)] = 57122, - [SMALL_STATE(1471)] = 57129, - [SMALL_STATE(1472)] = 57136, - [SMALL_STATE(1473)] = 57143, - [SMALL_STATE(1474)] = 57150, - [SMALL_STATE(1475)] = 57157, - [SMALL_STATE(1476)] = 57164, - [SMALL_STATE(1477)] = 57171, - [SMALL_STATE(1478)] = 57178, - [SMALL_STATE(1479)] = 57185, - [SMALL_STATE(1480)] = 57192, - [SMALL_STATE(1481)] = 57199, - [SMALL_STATE(1482)] = 57206, - [SMALL_STATE(1483)] = 57213, - [SMALL_STATE(1484)] = 57220, - [SMALL_STATE(1485)] = 57227, - [SMALL_STATE(1486)] = 57234, - [SMALL_STATE(1487)] = 57241, - [SMALL_STATE(1488)] = 57248, - [SMALL_STATE(1489)] = 57255, - [SMALL_STATE(1490)] = 57262, - [SMALL_STATE(1491)] = 57269, - [SMALL_STATE(1492)] = 57276, - [SMALL_STATE(1493)] = 57283, - [SMALL_STATE(1494)] = 57290, - [SMALL_STATE(1495)] = 57297, - [SMALL_STATE(1496)] = 57304, - [SMALL_STATE(1497)] = 57311, - [SMALL_STATE(1498)] = 57318, - [SMALL_STATE(1499)] = 57325, - [SMALL_STATE(1500)] = 57332, - [SMALL_STATE(1501)] = 57339, - [SMALL_STATE(1502)] = 57346, - [SMALL_STATE(1503)] = 57353, - [SMALL_STATE(1504)] = 57360, - [SMALL_STATE(1505)] = 57367, - [SMALL_STATE(1506)] = 57374, - [SMALL_STATE(1507)] = 57381, - [SMALL_STATE(1508)] = 57388, - [SMALL_STATE(1509)] = 57395, - [SMALL_STATE(1510)] = 57402, - [SMALL_STATE(1511)] = 57409, - [SMALL_STATE(1512)] = 57416, - [SMALL_STATE(1513)] = 57423, - [SMALL_STATE(1514)] = 57430, - [SMALL_STATE(1515)] = 57437, - [SMALL_STATE(1516)] = 57444, - [SMALL_STATE(1517)] = 57451, - [SMALL_STATE(1518)] = 57458, - [SMALL_STATE(1519)] = 57465, - [SMALL_STATE(1520)] = 57472, - [SMALL_STATE(1521)] = 57479, - [SMALL_STATE(1522)] = 57486, - [SMALL_STATE(1523)] = 57493, - [SMALL_STATE(1524)] = 57500, - [SMALL_STATE(1525)] = 57507, - [SMALL_STATE(1526)] = 57514, - [SMALL_STATE(1527)] = 57521, - [SMALL_STATE(1528)] = 57528, - [SMALL_STATE(1529)] = 57535, - [SMALL_STATE(1530)] = 57542, - [SMALL_STATE(1531)] = 57549, - [SMALL_STATE(1532)] = 57556, - [SMALL_STATE(1533)] = 57563, - [SMALL_STATE(1534)] = 57570, - [SMALL_STATE(1535)] = 57577, - [SMALL_STATE(1536)] = 57584, - [SMALL_STATE(1537)] = 57591, - [SMALL_STATE(1538)] = 57598, - [SMALL_STATE(1539)] = 57605, - [SMALL_STATE(1540)] = 57612, - [SMALL_STATE(1541)] = 57619, - [SMALL_STATE(1542)] = 57626, - [SMALL_STATE(1543)] = 57633, - [SMALL_STATE(1544)] = 57640, - [SMALL_STATE(1545)] = 57647, - [SMALL_STATE(1546)] = 57654, - [SMALL_STATE(1547)] = 57661, - [SMALL_STATE(1548)] = 57668, - [SMALL_STATE(1549)] = 57675, - [SMALL_STATE(1550)] = 57682, - [SMALL_STATE(1551)] = 57689, - [SMALL_STATE(1552)] = 57696, - [SMALL_STATE(1553)] = 57703, - [SMALL_STATE(1554)] = 57710, - [SMALL_STATE(1555)] = 57717, - [SMALL_STATE(1556)] = 57724, - [SMALL_STATE(1557)] = 57731, - [SMALL_STATE(1558)] = 57738, - [SMALL_STATE(1559)] = 57745, - [SMALL_STATE(1560)] = 57752, - [SMALL_STATE(1561)] = 57759, - [SMALL_STATE(1562)] = 57766, - [SMALL_STATE(1563)] = 57773, - [SMALL_STATE(1564)] = 57780, - [SMALL_STATE(1565)] = 57787, - [SMALL_STATE(1566)] = 57794, - [SMALL_STATE(1567)] = 57801, - [SMALL_STATE(1568)] = 57808, - [SMALL_STATE(1569)] = 57815, - [SMALL_STATE(1570)] = 57822, - [SMALL_STATE(1571)] = 57829, - [SMALL_STATE(1572)] = 57836, - [SMALL_STATE(1573)] = 57843, - [SMALL_STATE(1574)] = 57850, - [SMALL_STATE(1575)] = 57857, - [SMALL_STATE(1576)] = 57864, - [SMALL_STATE(1577)] = 57871, - [SMALL_STATE(1578)] = 57878, - [SMALL_STATE(1579)] = 57885, - [SMALL_STATE(1580)] = 57892, - [SMALL_STATE(1581)] = 57899, - [SMALL_STATE(1582)] = 57906, - [SMALL_STATE(1583)] = 57913, - [SMALL_STATE(1584)] = 57920, - [SMALL_STATE(1585)] = 57927, - [SMALL_STATE(1586)] = 57934, - [SMALL_STATE(1587)] = 57941, - [SMALL_STATE(1588)] = 57948, - [SMALL_STATE(1589)] = 57955, - [SMALL_STATE(1590)] = 57962, - [SMALL_STATE(1591)] = 57969, - [SMALL_STATE(1592)] = 57976, - [SMALL_STATE(1593)] = 57983, - [SMALL_STATE(1594)] = 57990, - [SMALL_STATE(1595)] = 57997, - [SMALL_STATE(1596)] = 58004, - [SMALL_STATE(1597)] = 58011, - [SMALL_STATE(1598)] = 58018, - [SMALL_STATE(1599)] = 58025, - [SMALL_STATE(1600)] = 58032, - [SMALL_STATE(1601)] = 58039, - [SMALL_STATE(1602)] = 58046, - [SMALL_STATE(1603)] = 58053, - [SMALL_STATE(1604)] = 58060, - [SMALL_STATE(1605)] = 58067, - [SMALL_STATE(1606)] = 58074, - [SMALL_STATE(1607)] = 58081, - [SMALL_STATE(1608)] = 58088, - [SMALL_STATE(1609)] = 58095, - [SMALL_STATE(1610)] = 58102, - [SMALL_STATE(1611)] = 58109, - [SMALL_STATE(1612)] = 58116, - [SMALL_STATE(1613)] = 58123, - [SMALL_STATE(1614)] = 58130, - [SMALL_STATE(1615)] = 58137, - [SMALL_STATE(1616)] = 58144, - [SMALL_STATE(1617)] = 58151, - [SMALL_STATE(1618)] = 58158, - [SMALL_STATE(1619)] = 58165, - [SMALL_STATE(1620)] = 58172, - [SMALL_STATE(1621)] = 58179, - [SMALL_STATE(1622)] = 58186, - [SMALL_STATE(1623)] = 58193, - [SMALL_STATE(1624)] = 58200, - [SMALL_STATE(1625)] = 58207, - [SMALL_STATE(1626)] = 58214, - [SMALL_STATE(1627)] = 58221, - [SMALL_STATE(1628)] = 58228, - [SMALL_STATE(1629)] = 58235, - [SMALL_STATE(1630)] = 58242, - [SMALL_STATE(1631)] = 58249, - [SMALL_STATE(1632)] = 58256, - [SMALL_STATE(1633)] = 58263, - [SMALL_STATE(1634)] = 58270, - [SMALL_STATE(1635)] = 58277, - [SMALL_STATE(1636)] = 58284, - [SMALL_STATE(1637)] = 58291, - [SMALL_STATE(1638)] = 58298, - [SMALL_STATE(1639)] = 58305, - [SMALL_STATE(1640)] = 58312, - [SMALL_STATE(1641)] = 58319, - [SMALL_STATE(1642)] = 58326, - [SMALL_STATE(1643)] = 58333, - [SMALL_STATE(1644)] = 58340, - [SMALL_STATE(1645)] = 58347, - [SMALL_STATE(1646)] = 58354, - [SMALL_STATE(1647)] = 58361, - [SMALL_STATE(1648)] = 58368, - [SMALL_STATE(1649)] = 58375, - [SMALL_STATE(1650)] = 58382, - [SMALL_STATE(1651)] = 58389, - [SMALL_STATE(1652)] = 58396, - [SMALL_STATE(1653)] = 58403, - [SMALL_STATE(1654)] = 58410, - [SMALL_STATE(1655)] = 58417, - [SMALL_STATE(1656)] = 58424, - [SMALL_STATE(1657)] = 58431, - [SMALL_STATE(1658)] = 58438, - [SMALL_STATE(1659)] = 58445, - [SMALL_STATE(1660)] = 58452, - [SMALL_STATE(1661)] = 58459, - [SMALL_STATE(1662)] = 58466, - [SMALL_STATE(1663)] = 58473, - [SMALL_STATE(1664)] = 58480, - [SMALL_STATE(1665)] = 58487, - [SMALL_STATE(1666)] = 58494, - [SMALL_STATE(1667)] = 58501, - [SMALL_STATE(1668)] = 58508, - [SMALL_STATE(1669)] = 58515, - [SMALL_STATE(1670)] = 58522, - [SMALL_STATE(1671)] = 58529, - [SMALL_STATE(1672)] = 58536, - [SMALL_STATE(1673)] = 58543, - [SMALL_STATE(1674)] = 58550, - [SMALL_STATE(1675)] = 58557, - [SMALL_STATE(1676)] = 58564, - [SMALL_STATE(1677)] = 58571, - [SMALL_STATE(1678)] = 58578, - [SMALL_STATE(1679)] = 58585, - [SMALL_STATE(1680)] = 58592, - [SMALL_STATE(1681)] = 58599, - [SMALL_STATE(1682)] = 58606, - [SMALL_STATE(1683)] = 58613, - [SMALL_STATE(1684)] = 58620, - [SMALL_STATE(1685)] = 58627, - [SMALL_STATE(1686)] = 58634, - [SMALL_STATE(1687)] = 58641, - [SMALL_STATE(1688)] = 58648, - [SMALL_STATE(1689)] = 58655, - [SMALL_STATE(1690)] = 58662, - [SMALL_STATE(1691)] = 58669, - [SMALL_STATE(1692)] = 58676, - [SMALL_STATE(1693)] = 58683, - [SMALL_STATE(1694)] = 58690, - [SMALL_STATE(1695)] = 58697, - [SMALL_STATE(1696)] = 58704, - [SMALL_STATE(1697)] = 58711, - [SMALL_STATE(1698)] = 58718, - [SMALL_STATE(1699)] = 58725, - [SMALL_STATE(1700)] = 58732, - [SMALL_STATE(1701)] = 58739, - [SMALL_STATE(1702)] = 58746, - [SMALL_STATE(1703)] = 58753, - [SMALL_STATE(1704)] = 58760, - [SMALL_STATE(1705)] = 58767, - [SMALL_STATE(1706)] = 58774, - [SMALL_STATE(1707)] = 58781, - [SMALL_STATE(1708)] = 58788, - [SMALL_STATE(1709)] = 58795, - [SMALL_STATE(1710)] = 58802, - [SMALL_STATE(1711)] = 58809, - [SMALL_STATE(1712)] = 58816, - [SMALL_STATE(1713)] = 58823, - [SMALL_STATE(1714)] = 58830, - [SMALL_STATE(1715)] = 58837, - [SMALL_STATE(1716)] = 58844, - [SMALL_STATE(1717)] = 58851, - [SMALL_STATE(1718)] = 58858, - [SMALL_STATE(1719)] = 58865, - [SMALL_STATE(1720)] = 58872, - [SMALL_STATE(1721)] = 58879, - [SMALL_STATE(1722)] = 58886, - [SMALL_STATE(1723)] = 58893, - [SMALL_STATE(1724)] = 58900, + [SMALL_STATE(31)] = 1260, + [SMALL_STATE(32)] = 1386, + [SMALL_STATE(33)] = 1512, + [SMALL_STATE(34)] = 1629, + [SMALL_STATE(35)] = 1746, + [SMALL_STATE(36)] = 1863, + [SMALL_STATE(37)] = 1980, + [SMALL_STATE(38)] = 2097, + [SMALL_STATE(39)] = 2214, + [SMALL_STATE(40)] = 2331, + [SMALL_STATE(41)] = 2448, + [SMALL_STATE(42)] = 2565, + [SMALL_STATE(43)] = 2682, + [SMALL_STATE(44)] = 2799, + [SMALL_STATE(45)] = 2916, + [SMALL_STATE(46)] = 3033, + [SMALL_STATE(47)] = 3147, + [SMALL_STATE(48)] = 3261, + [SMALL_STATE(49)] = 3375, + [SMALL_STATE(50)] = 3489, + [SMALL_STATE(51)] = 3603, + [SMALL_STATE(52)] = 3717, + [SMALL_STATE(53)] = 3831, + [SMALL_STATE(54)] = 3945, + [SMALL_STATE(55)] = 4059, + [SMALL_STATE(56)] = 4173, + [SMALL_STATE(57)] = 4287, + [SMALL_STATE(58)] = 4401, + [SMALL_STATE(59)] = 4515, + [SMALL_STATE(60)] = 4629, + [SMALL_STATE(61)] = 4743, + [SMALL_STATE(62)] = 4857, + [SMALL_STATE(63)] = 4971, + [SMALL_STATE(64)] = 5085, + [SMALL_STATE(65)] = 5199, + [SMALL_STATE(66)] = 5313, + [SMALL_STATE(67)] = 5427, + [SMALL_STATE(68)] = 5541, + [SMALL_STATE(69)] = 5655, + [SMALL_STATE(70)] = 5769, + [SMALL_STATE(71)] = 5883, + [SMALL_STATE(72)] = 5997, + [SMALL_STATE(73)] = 6111, + [SMALL_STATE(74)] = 6225, + [SMALL_STATE(75)] = 6339, + [SMALL_STATE(76)] = 6453, + [SMALL_STATE(77)] = 6567, + [SMALL_STATE(78)] = 6681, + [SMALL_STATE(79)] = 6795, + [SMALL_STATE(80)] = 6911, + [SMALL_STATE(81)] = 7025, + [SMALL_STATE(82)] = 7139, + [SMALL_STATE(83)] = 7253, + [SMALL_STATE(84)] = 7367, + [SMALL_STATE(85)] = 7481, + [SMALL_STATE(86)] = 7595, + [SMALL_STATE(87)] = 7709, + [SMALL_STATE(88)] = 7823, + [SMALL_STATE(89)] = 7937, + [SMALL_STATE(90)] = 8051, + [SMALL_STATE(91)] = 8165, + [SMALL_STATE(92)] = 8279, + [SMALL_STATE(93)] = 8393, + [SMALL_STATE(94)] = 8507, + [SMALL_STATE(95)] = 8621, + [SMALL_STATE(96)] = 8735, + [SMALL_STATE(97)] = 8849, + [SMALL_STATE(98)] = 8963, + [SMALL_STATE(99)] = 9077, + [SMALL_STATE(100)] = 9191, + [SMALL_STATE(101)] = 9305, + [SMALL_STATE(102)] = 9419, + [SMALL_STATE(103)] = 9533, + [SMALL_STATE(104)] = 9647, + [SMALL_STATE(105)] = 9761, + [SMALL_STATE(106)] = 9875, + [SMALL_STATE(107)] = 9989, + [SMALL_STATE(108)] = 10103, + [SMALL_STATE(109)] = 10217, + [SMALL_STATE(110)] = 10331, + [SMALL_STATE(111)] = 10445, + [SMALL_STATE(112)] = 10559, + [SMALL_STATE(113)] = 10673, + [SMALL_STATE(114)] = 10787, + [SMALL_STATE(115)] = 10901, + [SMALL_STATE(116)] = 11015, + [SMALL_STATE(117)] = 11129, + [SMALL_STATE(118)] = 11243, + [SMALL_STATE(119)] = 11357, + [SMALL_STATE(120)] = 11471, + [SMALL_STATE(121)] = 11585, + [SMALL_STATE(122)] = 11699, + [SMALL_STATE(123)] = 11813, + [SMALL_STATE(124)] = 11927, + [SMALL_STATE(125)] = 12041, + [SMALL_STATE(126)] = 12155, + [SMALL_STATE(127)] = 12269, + [SMALL_STATE(128)] = 12383, + [SMALL_STATE(129)] = 12497, + [SMALL_STATE(130)] = 12611, + [SMALL_STATE(131)] = 12725, + [SMALL_STATE(132)] = 12839, + [SMALL_STATE(133)] = 12953, + [SMALL_STATE(134)] = 13067, + [SMALL_STATE(135)] = 13181, + [SMALL_STATE(136)] = 13295, + [SMALL_STATE(137)] = 13409, + [SMALL_STATE(138)] = 13523, + [SMALL_STATE(139)] = 13637, + [SMALL_STATE(140)] = 13751, + [SMALL_STATE(141)] = 13865, + [SMALL_STATE(142)] = 13979, + [SMALL_STATE(143)] = 14093, + [SMALL_STATE(144)] = 14207, + [SMALL_STATE(145)] = 14321, + [SMALL_STATE(146)] = 14435, + [SMALL_STATE(147)] = 14549, + [SMALL_STATE(148)] = 14663, + [SMALL_STATE(149)] = 14777, + [SMALL_STATE(150)] = 14891, + [SMALL_STATE(151)] = 15005, + [SMALL_STATE(152)] = 15119, + [SMALL_STATE(153)] = 15233, + [SMALL_STATE(154)] = 15347, + [SMALL_STATE(155)] = 15461, + [SMALL_STATE(156)] = 15575, + [SMALL_STATE(157)] = 15689, + [SMALL_STATE(158)] = 15803, + [SMALL_STATE(159)] = 15917, + [SMALL_STATE(160)] = 16031, + [SMALL_STATE(161)] = 16145, + [SMALL_STATE(162)] = 16259, + [SMALL_STATE(163)] = 16373, + [SMALL_STATE(164)] = 16487, + [SMALL_STATE(165)] = 16601, + [SMALL_STATE(166)] = 16715, + [SMALL_STATE(167)] = 16829, + [SMALL_STATE(168)] = 16943, + [SMALL_STATE(169)] = 17057, + [SMALL_STATE(170)] = 17171, + [SMALL_STATE(171)] = 17285, + [SMALL_STATE(172)] = 17399, + [SMALL_STATE(173)] = 17513, + [SMALL_STATE(174)] = 17627, + [SMALL_STATE(175)] = 17741, + [SMALL_STATE(176)] = 17855, + [SMALL_STATE(177)] = 17969, + [SMALL_STATE(178)] = 18083, + [SMALL_STATE(179)] = 18197, + [SMALL_STATE(180)] = 18311, + [SMALL_STATE(181)] = 18425, + [SMALL_STATE(182)] = 18539, + [SMALL_STATE(183)] = 18653, + [SMALL_STATE(184)] = 18767, + [SMALL_STATE(185)] = 18881, + [SMALL_STATE(186)] = 18995, + [SMALL_STATE(187)] = 19109, + [SMALL_STATE(188)] = 19223, + [SMALL_STATE(189)] = 19337, + [SMALL_STATE(190)] = 19451, + [SMALL_STATE(191)] = 19565, + [SMALL_STATE(192)] = 19679, + [SMALL_STATE(193)] = 19793, + [SMALL_STATE(194)] = 19907, + [SMALL_STATE(195)] = 20021, + [SMALL_STATE(196)] = 20135, + [SMALL_STATE(197)] = 20249, + [SMALL_STATE(198)] = 20363, + [SMALL_STATE(199)] = 20477, + [SMALL_STATE(200)] = 20591, + [SMALL_STATE(201)] = 20705, + [SMALL_STATE(202)] = 20819, + [SMALL_STATE(203)] = 20933, + [SMALL_STATE(204)] = 21047, + [SMALL_STATE(205)] = 21161, + [SMALL_STATE(206)] = 21275, + [SMALL_STATE(207)] = 21389, + [SMALL_STATE(208)] = 21503, + [SMALL_STATE(209)] = 21617, + [SMALL_STATE(210)] = 21731, + [SMALL_STATE(211)] = 21845, + [SMALL_STATE(212)] = 21959, + [SMALL_STATE(213)] = 22073, + [SMALL_STATE(214)] = 22187, + [SMALL_STATE(215)] = 22301, + [SMALL_STATE(216)] = 22415, + [SMALL_STATE(217)] = 22529, + [SMALL_STATE(218)] = 22643, + [SMALL_STATE(219)] = 22757, + [SMALL_STATE(220)] = 22871, + [SMALL_STATE(221)] = 22985, + [SMALL_STATE(222)] = 23099, + [SMALL_STATE(223)] = 23213, + [SMALL_STATE(224)] = 23327, + [SMALL_STATE(225)] = 23441, + [SMALL_STATE(226)] = 23555, + [SMALL_STATE(227)] = 23611, + [SMALL_STATE(228)] = 23667, + [SMALL_STATE(229)] = 23715, + [SMALL_STATE(230)] = 23763, + [SMALL_STATE(231)] = 23820, + [SMALL_STATE(232)] = 23870, + [SMALL_STATE(233)] = 23920, + [SMALL_STATE(234)] = 23995, + [SMALL_STATE(235)] = 24068, + [SMALL_STATE(236)] = 24131, + [SMALL_STATE(237)] = 24188, + [SMALL_STATE(238)] = 24263, + [SMALL_STATE(239)] = 24338, + [SMALL_STATE(240)] = 24407, + [SMALL_STATE(241)] = 24474, + [SMALL_STATE(242)] = 24549, + [SMALL_STATE(243)] = 24624, + [SMALL_STATE(244)] = 24685, + [SMALL_STATE(245)] = 24740, + [SMALL_STATE(246)] = 24815, + [SMALL_STATE(247)] = 24890, + [SMALL_STATE(248)] = 24965, + [SMALL_STATE(249)] = 25040, + [SMALL_STATE(250)] = 25113, + [SMALL_STATE(251)] = 25164, + [SMALL_STATE(252)] = 25239, + [SMALL_STATE(253)] = 25314, + [SMALL_STATE(254)] = 25389, + [SMALL_STATE(255)] = 25444, + [SMALL_STATE(256)] = 25489, + [SMALL_STATE(257)] = 25564, + [SMALL_STATE(258)] = 25608, + [SMALL_STATE(259)] = 25652, + [SMALL_STATE(260)] = 25696, + [SMALL_STATE(261)] = 25740, + [SMALL_STATE(262)] = 25784, + [SMALL_STATE(263)] = 25828, + [SMALL_STATE(264)] = 25872, + [SMALL_STATE(265)] = 25916, + [SMALL_STATE(266)] = 25960, + [SMALL_STATE(267)] = 26004, + [SMALL_STATE(268)] = 26048, + [SMALL_STATE(269)] = 26092, + [SMALL_STATE(270)] = 26136, + [SMALL_STATE(271)] = 26180, + [SMALL_STATE(272)] = 26224, + [SMALL_STATE(273)] = 26268, + [SMALL_STATE(274)] = 26312, + [SMALL_STATE(275)] = 26356, + [SMALL_STATE(276)] = 26400, + [SMALL_STATE(277)] = 26444, + [SMALL_STATE(278)] = 26488, + [SMALL_STATE(279)] = 26532, + [SMALL_STATE(280)] = 26576, + [SMALL_STATE(281)] = 26620, + [SMALL_STATE(282)] = 26664, + [SMALL_STATE(283)] = 26708, + [SMALL_STATE(284)] = 26752, + [SMALL_STATE(285)] = 26796, + [SMALL_STATE(286)] = 26840, + [SMALL_STATE(287)] = 26884, + [SMALL_STATE(288)] = 26928, + [SMALL_STATE(289)] = 26972, + [SMALL_STATE(290)] = 27016, + [SMALL_STATE(291)] = 27060, + [SMALL_STATE(292)] = 27104, + [SMALL_STATE(293)] = 27158, + [SMALL_STATE(294)] = 27202, + [SMALL_STATE(295)] = 27246, + [SMALL_STATE(296)] = 27293, + [SMALL_STATE(297)] = 27340, + [SMALL_STATE(298)] = 27408, + [SMALL_STATE(299)] = 27478, + [SMALL_STATE(300)] = 27548, + [SMALL_STATE(301)] = 27618, + [SMALL_STATE(302)] = 27688, + [SMALL_STATE(303)] = 27758, + [SMALL_STATE(304)] = 27828, + [SMALL_STATE(305)] = 27898, + [SMALL_STATE(306)] = 27968, + [SMALL_STATE(307)] = 28038, + [SMALL_STATE(308)] = 28108, + [SMALL_STATE(309)] = 28178, + [SMALL_STATE(310)] = 28248, + [SMALL_STATE(311)] = 28318, + [SMALL_STATE(312)] = 28388, + [SMALL_STATE(313)] = 28458, + [SMALL_STATE(314)] = 28528, + [SMALL_STATE(315)] = 28598, + [SMALL_STATE(316)] = 28668, + [SMALL_STATE(317)] = 28738, + [SMALL_STATE(318)] = 28808, + [SMALL_STATE(319)] = 28878, + [SMALL_STATE(320)] = 28948, + [SMALL_STATE(321)] = 29018, + [SMALL_STATE(322)] = 29088, + [SMALL_STATE(323)] = 29158, + [SMALL_STATE(324)] = 29228, + [SMALL_STATE(325)] = 29298, + [SMALL_STATE(326)] = 29368, + [SMALL_STATE(327)] = 29438, + [SMALL_STATE(328)] = 29508, + [SMALL_STATE(329)] = 29578, + [SMALL_STATE(330)] = 29626, + [SMALL_STATE(331)] = 29696, + [SMALL_STATE(332)] = 29748, + [SMALL_STATE(333)] = 29818, + [SMALL_STATE(334)] = 29888, + [SMALL_STATE(335)] = 29942, + [SMALL_STATE(336)] = 30002, + [SMALL_STATE(337)] = 30066, + [SMALL_STATE(338)] = 30128, + [SMALL_STATE(339)] = 30186, + [SMALL_STATE(340)] = 30238, + [SMALL_STATE(341)] = 30308, + [SMALL_STATE(342)] = 30378, + [SMALL_STATE(343)] = 30446, + [SMALL_STATE(344)] = 30516, + [SMALL_STATE(345)] = 30586, + [SMALL_STATE(346)] = 30656, + [SMALL_STATE(347)] = 30726, + [SMALL_STATE(348)] = 30796, + [SMALL_STATE(349)] = 30866, + [SMALL_STATE(350)] = 30936, + [SMALL_STATE(351)] = 31006, + [SMALL_STATE(352)] = 31076, + [SMALL_STATE(353)] = 31146, + [SMALL_STATE(354)] = 31216, + [SMALL_STATE(355)] = 31258, + [SMALL_STATE(356)] = 31328, + [SMALL_STATE(357)] = 31398, + [SMALL_STATE(358)] = 31439, + [SMALL_STATE(359)] = 31480, + [SMALL_STATE(360)] = 31521, + [SMALL_STATE(361)] = 31562, + [SMALL_STATE(362)] = 31603, + [SMALL_STATE(363)] = 31644, + [SMALL_STATE(364)] = 31685, + [SMALL_STATE(365)] = 31726, + [SMALL_STATE(366)] = 31767, + [SMALL_STATE(367)] = 31808, + [SMALL_STATE(368)] = 31849, + [SMALL_STATE(369)] = 31890, + [SMALL_STATE(370)] = 31931, + [SMALL_STATE(371)] = 31972, + [SMALL_STATE(372)] = 32013, + [SMALL_STATE(373)] = 32054, + [SMALL_STATE(374)] = 32095, + [SMALL_STATE(375)] = 32136, + [SMALL_STATE(376)] = 32177, + [SMALL_STATE(377)] = 32218, + [SMALL_STATE(378)] = 32259, + [SMALL_STATE(379)] = 32300, + [SMALL_STATE(380)] = 32341, + [SMALL_STATE(381)] = 32382, + [SMALL_STATE(382)] = 32423, + [SMALL_STATE(383)] = 32464, + [SMALL_STATE(384)] = 32505, + [SMALL_STATE(385)] = 32546, + [SMALL_STATE(386)] = 32587, + [SMALL_STATE(387)] = 32628, + [SMALL_STATE(388)] = 32669, + [SMALL_STATE(389)] = 32710, + [SMALL_STATE(390)] = 32751, + [SMALL_STATE(391)] = 32792, + [SMALL_STATE(392)] = 32833, + [SMALL_STATE(393)] = 32874, + [SMALL_STATE(394)] = 32915, + [SMALL_STATE(395)] = 32985, + [SMALL_STATE(396)] = 33055, + [SMALL_STATE(397)] = 33096, + [SMALL_STATE(398)] = 33136, + [SMALL_STATE(399)] = 33172, + [SMALL_STATE(400)] = 33221, + [SMALL_STATE(401)] = 33283, + [SMALL_STATE(402)] = 33345, + [SMALL_STATE(403)] = 33407, + [SMALL_STATE(404)] = 33451, + [SMALL_STATE(405)] = 33513, + [SMALL_STATE(406)] = 33575, + [SMALL_STATE(407)] = 33637, + [SMALL_STATE(408)] = 33699, + [SMALL_STATE(409)] = 33761, + [SMALL_STATE(410)] = 33807, + [SMALL_STATE(411)] = 33853, + [SMALL_STATE(412)] = 33915, + [SMALL_STATE(413)] = 33977, + [SMALL_STATE(414)] = 34039, + [SMALL_STATE(415)] = 34089, + [SMALL_STATE(416)] = 34151, + [SMALL_STATE(417)] = 34213, + [SMALL_STATE(418)] = 34275, + [SMALL_STATE(419)] = 34337, + [SMALL_STATE(420)] = 34399, + [SMALL_STATE(421)] = 34461, + [SMALL_STATE(422)] = 34523, + [SMALL_STATE(423)] = 34585, + [SMALL_STATE(424)] = 34647, + [SMALL_STATE(425)] = 34709, + [SMALL_STATE(426)] = 34771, + [SMALL_STATE(427)] = 34833, + [SMALL_STATE(428)] = 34895, + [SMALL_STATE(429)] = 34957, + [SMALL_STATE(430)] = 35019, + [SMALL_STATE(431)] = 35081, + [SMALL_STATE(432)] = 35143, + [SMALL_STATE(433)] = 35205, + [SMALL_STATE(434)] = 35267, + [SMALL_STATE(435)] = 35329, + [SMALL_STATE(436)] = 35391, + [SMALL_STATE(437)] = 35453, + [SMALL_STATE(438)] = 35490, + [SMALL_STATE(439)] = 35527, + [SMALL_STATE(440)] = 35568, + [SMALL_STATE(441)] = 35632, + [SMALL_STATE(442)] = 35692, + [SMALL_STATE(443)] = 35724, + [SMALL_STATE(444)] = 35784, + [SMALL_STATE(445)] = 35848, + [SMALL_STATE(446)] = 35908, + [SMALL_STATE(447)] = 35968, + [SMALL_STATE(448)] = 36028, + [SMALL_STATE(449)] = 36088, + [SMALL_STATE(450)] = 36148, + [SMALL_STATE(451)] = 36208, + [SMALL_STATE(452)] = 36268, + [SMALL_STATE(453)] = 36332, + [SMALL_STATE(454)] = 36374, + [SMALL_STATE(455)] = 36432, + [SMALL_STATE(456)] = 36490, + [SMALL_STATE(457)] = 36550, + [SMALL_STATE(458)] = 36614, + [SMALL_STATE(459)] = 36674, + [SMALL_STATE(460)] = 36734, + [SMALL_STATE(461)] = 36772, + [SMALL_STATE(462)] = 36832, + [SMALL_STATE(463)] = 36892, + [SMALL_STATE(464)] = 36956, + [SMALL_STATE(465)] = 37020, + [SMALL_STATE(466)] = 37064, + [SMALL_STATE(467)] = 37114, + [SMALL_STATE(468)] = 37178, + [SMALL_STATE(469)] = 37232, + [SMALL_STATE(470)] = 37284, + [SMALL_STATE(471)] = 37332, + [SMALL_STATE(472)] = 37374, + [SMALL_STATE(473)] = 37433, + [SMALL_STATE(474)] = 37464, + [SMALL_STATE(475)] = 37495, + [SMALL_STATE(476)] = 37526, + [SMALL_STATE(477)] = 37557, + [SMALL_STATE(478)] = 37588, + [SMALL_STATE(479)] = 37619, + [SMALL_STATE(480)] = 37650, + [SMALL_STATE(481)] = 37681, + [SMALL_STATE(482)] = 37712, + [SMALL_STATE(483)] = 37743, + [SMALL_STATE(484)] = 37774, + [SMALL_STATE(485)] = 37805, + [SMALL_STATE(486)] = 37836, + [SMALL_STATE(487)] = 37867, + [SMALL_STATE(488)] = 37898, + [SMALL_STATE(489)] = 37929, + [SMALL_STATE(490)] = 37990, + [SMALL_STATE(491)] = 38045, + [SMALL_STATE(492)] = 38076, + [SMALL_STATE(493)] = 38107, + [SMALL_STATE(494)] = 38138, + [SMALL_STATE(495)] = 38169, + [SMALL_STATE(496)] = 38200, + [SMALL_STATE(497)] = 38259, + [SMALL_STATE(498)] = 38290, + [SMALL_STATE(499)] = 38349, + [SMALL_STATE(500)] = 38380, + [SMALL_STATE(501)] = 38411, + [SMALL_STATE(502)] = 38442, + [SMALL_STATE(503)] = 38501, + [SMALL_STATE(504)] = 38536, + [SMALL_STATE(505)] = 38597, + [SMALL_STATE(506)] = 38652, + [SMALL_STATE(507)] = 38711, + [SMALL_STATE(508)] = 38772, + [SMALL_STATE(509)] = 38803, + [SMALL_STATE(510)] = 38834, + [SMALL_STATE(511)] = 38865, + [SMALL_STATE(512)] = 38926, + [SMALL_STATE(513)] = 38985, + [SMALL_STATE(514)] = 39016, + [SMALL_STATE(515)] = 39047, + [SMALL_STATE(516)] = 39078, + [SMALL_STATE(517)] = 39109, + [SMALL_STATE(518)] = 39140, + [SMALL_STATE(519)] = 39199, + [SMALL_STATE(520)] = 39260, + [SMALL_STATE(521)] = 39315, + [SMALL_STATE(522)] = 39376, + [SMALL_STATE(523)] = 39437, + [SMALL_STATE(524)] = 39468, + [SMALL_STATE(525)] = 39499, + [SMALL_STATE(526)] = 39530, + [SMALL_STATE(527)] = 39561, + [SMALL_STATE(528)] = 39619, + [SMALL_STATE(529)] = 39677, + [SMALL_STATE(530)] = 39735, + [SMALL_STATE(531)] = 39793, + [SMALL_STATE(532)] = 39851, + [SMALL_STATE(533)] = 39909, + [SMALL_STATE(534)] = 39967, + [SMALL_STATE(535)] = 40025, + [SMALL_STATE(536)] = 40083, + [SMALL_STATE(537)] = 40141, + [SMALL_STATE(538)] = 40199, + [SMALL_STATE(539)] = 40251, + [SMALL_STATE(540)] = 40309, + [SMALL_STATE(541)] = 40361, + [SMALL_STATE(542)] = 40419, + [SMALL_STATE(543)] = 40477, + [SMALL_STATE(544)] = 40529, + [SMALL_STATE(545)] = 40587, + [SMALL_STATE(546)] = 40645, + [SMALL_STATE(547)] = 40703, + [SMALL_STATE(548)] = 40757, + [SMALL_STATE(549)] = 40815, + [SMALL_STATE(550)] = 40873, + [SMALL_STATE(551)] = 40931, + [SMALL_STATE(552)] = 40983, + [SMALL_STATE(553)] = 41041, + [SMALL_STATE(554)] = 41099, + [SMALL_STATE(555)] = 41157, + [SMALL_STATE(556)] = 41215, + [SMALL_STATE(557)] = 41273, + [SMALL_STATE(558)] = 41331, + [SMALL_STATE(559)] = 41389, + [SMALL_STATE(560)] = 41447, + [SMALL_STATE(561)] = 41505, + [SMALL_STATE(562)] = 41563, + [SMALL_STATE(563)] = 41621, + [SMALL_STATE(564)] = 41679, + [SMALL_STATE(565)] = 41737, + [SMALL_STATE(566)] = 41795, + [SMALL_STATE(567)] = 41853, + [SMALL_STATE(568)] = 41911, + [SMALL_STATE(569)] = 41969, + [SMALL_STATE(570)] = 42027, + [SMALL_STATE(571)] = 42085, + [SMALL_STATE(572)] = 42143, + [SMALL_STATE(573)] = 42195, + [SMALL_STATE(574)] = 42253, + [SMALL_STATE(575)] = 42311, + [SMALL_STATE(576)] = 42369, + [SMALL_STATE(577)] = 42427, + [SMALL_STATE(578)] = 42485, + [SMALL_STATE(579)] = 42543, + [SMALL_STATE(580)] = 42601, + [SMALL_STATE(581)] = 42653, + [SMALL_STATE(582)] = 42711, + [SMALL_STATE(583)] = 42763, + [SMALL_STATE(584)] = 42821, + [SMALL_STATE(585)] = 42879, + [SMALL_STATE(586)] = 42937, + [SMALL_STATE(587)] = 42995, + [SMALL_STATE(588)] = 43053, + [SMALL_STATE(589)] = 43111, + [SMALL_STATE(590)] = 43169, + [SMALL_STATE(591)] = 43201, + [SMALL_STATE(592)] = 43259, + [SMALL_STATE(593)] = 43317, + [SMALL_STATE(594)] = 43375, + [SMALL_STATE(595)] = 43427, + [SMALL_STATE(596)] = 43485, + [SMALL_STATE(597)] = 43543, + [SMALL_STATE(598)] = 43601, + [SMALL_STATE(599)] = 43659, + [SMALL_STATE(600)] = 43717, + [SMALL_STATE(601)] = 43775, + [SMALL_STATE(602)] = 43833, + [SMALL_STATE(603)] = 43891, + [SMALL_STATE(604)] = 43949, + [SMALL_STATE(605)] = 44003, + [SMALL_STATE(606)] = 44061, + [SMALL_STATE(607)] = 44119, + [SMALL_STATE(608)] = 44177, + [SMALL_STATE(609)] = 44235, + [SMALL_STATE(610)] = 44293, + [SMALL_STATE(611)] = 44351, + [SMALL_STATE(612)] = 44380, + [SMALL_STATE(613)] = 44435, + [SMALL_STATE(614)] = 44484, + [SMALL_STATE(615)] = 44539, + [SMALL_STATE(616)] = 44594, + [SMALL_STATE(617)] = 44643, + [SMALL_STATE(618)] = 44672, + [SMALL_STATE(619)] = 44727, + [SMALL_STATE(620)] = 44776, + [SMALL_STATE(621)] = 44831, + [SMALL_STATE(622)] = 44870, + [SMALL_STATE(623)] = 44899, + [SMALL_STATE(624)] = 44928, + [SMALL_STATE(625)] = 44983, + [SMALL_STATE(626)] = 45012, + [SMALL_STATE(627)] = 45067, + [SMALL_STATE(628)] = 45115, + [SMALL_STATE(629)] = 45163, + [SMALL_STATE(630)] = 45211, + [SMALL_STATE(631)] = 45256, + [SMALL_STATE(632)] = 45301, + [SMALL_STATE(633)] = 45346, + [SMALL_STATE(634)] = 45379, + [SMALL_STATE(635)] = 45412, + [SMALL_STATE(636)] = 45460, + [SMALL_STATE(637)] = 45508, + [SMALL_STATE(638)] = 45556, + [SMALL_STATE(639)] = 45604, + [SMALL_STATE(640)] = 45652, + [SMALL_STATE(641)] = 45700, + [SMALL_STATE(642)] = 45748, + [SMALL_STATE(643)] = 45796, + [SMALL_STATE(644)] = 45844, + [SMALL_STATE(645)] = 45871, + [SMALL_STATE(646)] = 45897, + [SMALL_STATE(647)] = 45923, + [SMALL_STATE(648)] = 45949, + [SMALL_STATE(649)] = 45970, + [SMALL_STATE(650)] = 45991, + [SMALL_STATE(651)] = 46016, + [SMALL_STATE(652)] = 46041, + [SMALL_STATE(653)] = 46066, + [SMALL_STATE(654)] = 46093, + [SMALL_STATE(655)] = 46120, + [SMALL_STATE(656)] = 46141, + [SMALL_STATE(657)] = 46166, + [SMALL_STATE(658)] = 46197, + [SMALL_STATE(659)] = 46217, + [SMALL_STATE(660)] = 46251, + [SMALL_STATE(661)] = 46271, + [SMALL_STATE(662)] = 46291, + [SMALL_STATE(663)] = 46325, + [SMALL_STATE(664)] = 46347, + [SMALL_STATE(665)] = 46367, + [SMALL_STATE(666)] = 46387, + [SMALL_STATE(667)] = 46407, + [SMALL_STATE(668)] = 46429, + [SMALL_STATE(669)] = 46449, + [SMALL_STATE(670)] = 46483, + [SMALL_STATE(671)] = 46503, + [SMALL_STATE(672)] = 46525, + [SMALL_STATE(673)] = 46545, + [SMALL_STATE(674)] = 46565, + [SMALL_STATE(675)] = 46587, + [SMALL_STATE(676)] = 46621, + [SMALL_STATE(677)] = 46641, + [SMALL_STATE(678)] = 46661, + [SMALL_STATE(679)] = 46681, + [SMALL_STATE(680)] = 46701, + [SMALL_STATE(681)] = 46721, + [SMALL_STATE(682)] = 46755, + [SMALL_STATE(683)] = 46775, + [SMALL_STATE(684)] = 46795, + [SMALL_STATE(685)] = 46815, + [SMALL_STATE(686)] = 46837, + [SMALL_STATE(687)] = 46871, + [SMALL_STATE(688)] = 46905, + [SMALL_STATE(689)] = 46939, + [SMALL_STATE(690)] = 46958, + [SMALL_STATE(691)] = 46977, + [SMALL_STATE(692)] = 47002, + [SMALL_STATE(693)] = 47021, + [SMALL_STATE(694)] = 47040, + [SMALL_STATE(695)] = 47059, + [SMALL_STATE(696)] = 47078, + [SMALL_STATE(697)] = 47097, + [SMALL_STATE(698)] = 47116, + [SMALL_STATE(699)] = 47135, + [SMALL_STATE(700)] = 47154, + [SMALL_STATE(701)] = 47173, + [SMALL_STATE(702)] = 47192, + [SMALL_STATE(703)] = 47211, + [SMALL_STATE(704)] = 47230, + [SMALL_STATE(705)] = 47249, + [SMALL_STATE(706)] = 47268, + [SMALL_STATE(707)] = 47287, + [SMALL_STATE(708)] = 47306, + [SMALL_STATE(709)] = 47325, + [SMALL_STATE(710)] = 47344, + [SMALL_STATE(711)] = 47363, + [SMALL_STATE(712)] = 47382, + [SMALL_STATE(713)] = 47401, + [SMALL_STATE(714)] = 47420, + [SMALL_STATE(715)] = 47439, + [SMALL_STATE(716)] = 47458, + [SMALL_STATE(717)] = 47477, + [SMALL_STATE(718)] = 47496, + [SMALL_STATE(719)] = 47515, + [SMALL_STATE(720)] = 47534, + [SMALL_STATE(721)] = 47553, + [SMALL_STATE(722)] = 47572, + [SMALL_STATE(723)] = 47591, + [SMALL_STATE(724)] = 47610, + [SMALL_STATE(725)] = 47629, + [SMALL_STATE(726)] = 47648, + [SMALL_STATE(727)] = 47667, + [SMALL_STATE(728)] = 47686, + [SMALL_STATE(729)] = 47705, + [SMALL_STATE(730)] = 47724, + [SMALL_STATE(731)] = 47743, + [SMALL_STATE(732)] = 47762, + [SMALL_STATE(733)] = 47781, + [SMALL_STATE(734)] = 47800, + [SMALL_STATE(735)] = 47819, + [SMALL_STATE(736)] = 47838, + [SMALL_STATE(737)] = 47857, + [SMALL_STATE(738)] = 47876, + [SMALL_STATE(739)] = 47895, + [SMALL_STATE(740)] = 47914, + [SMALL_STATE(741)] = 47933, + [SMALL_STATE(742)] = 47952, + [SMALL_STATE(743)] = 47971, + [SMALL_STATE(744)] = 47990, + [SMALL_STATE(745)] = 48009, + [SMALL_STATE(746)] = 48028, + [SMALL_STATE(747)] = 48047, + [SMALL_STATE(748)] = 48066, + [SMALL_STATE(749)] = 48085, + [SMALL_STATE(750)] = 48104, + [SMALL_STATE(751)] = 48123, + [SMALL_STATE(752)] = 48142, + [SMALL_STATE(753)] = 48169, + [SMALL_STATE(754)] = 48188, + [SMALL_STATE(755)] = 48207, + [SMALL_STATE(756)] = 48226, + [SMALL_STATE(757)] = 48245, + [SMALL_STATE(758)] = 48264, + [SMALL_STATE(759)] = 48283, + [SMALL_STATE(760)] = 48302, + [SMALL_STATE(761)] = 48336, + [SMALL_STATE(762)] = 48360, + [SMALL_STATE(763)] = 48394, + [SMALL_STATE(764)] = 48428, + [SMALL_STATE(765)] = 48462, + [SMALL_STATE(766)] = 48486, + [SMALL_STATE(767)] = 48520, + [SMALL_STATE(768)] = 48542, + [SMALL_STATE(769)] = 48576, + [SMALL_STATE(770)] = 48610, + [SMALL_STATE(771)] = 48644, + [SMALL_STATE(772)] = 48678, + [SMALL_STATE(773)] = 48712, + [SMALL_STATE(774)] = 48734, + [SMALL_STATE(775)] = 48756, + [SMALL_STATE(776)] = 48790, + [SMALL_STATE(777)] = 48824, + [SMALL_STATE(778)] = 48858, + [SMALL_STATE(779)] = 48892, + [SMALL_STATE(780)] = 48914, + [SMALL_STATE(781)] = 48948, + [SMALL_STATE(782)] = 48982, + [SMALL_STATE(783)] = 49016, + [SMALL_STATE(784)] = 49050, + [SMALL_STATE(785)] = 49084, + [SMALL_STATE(786)] = 49118, + [SMALL_STATE(787)] = 49152, + [SMALL_STATE(788)] = 49186, + [SMALL_STATE(789)] = 49220, + [SMALL_STATE(790)] = 49244, + [SMALL_STATE(791)] = 49278, + [SMALL_STATE(792)] = 49312, + [SMALL_STATE(793)] = 49346, + [SMALL_STATE(794)] = 49380, + [SMALL_STATE(795)] = 49414, + [SMALL_STATE(796)] = 49448, + [SMALL_STATE(797)] = 49482, + [SMALL_STATE(798)] = 49516, + [SMALL_STATE(799)] = 49550, + [SMALL_STATE(800)] = 49574, + [SMALL_STATE(801)] = 49608, + [SMALL_STATE(802)] = 49632, + [SMALL_STATE(803)] = 49653, + [SMALL_STATE(804)] = 49672, + [SMALL_STATE(805)] = 49691, + [SMALL_STATE(806)] = 49712, + [SMALL_STATE(807)] = 49733, + [SMALL_STATE(808)] = 49752, + [SMALL_STATE(809)] = 49771, + [SMALL_STATE(810)] = 49790, + [SMALL_STATE(811)] = 49807, + [SMALL_STATE(812)] = 49826, + [SMALL_STATE(813)] = 49847, + [SMALL_STATE(814)] = 49868, + [SMALL_STATE(815)] = 49897, + [SMALL_STATE(816)] = 49926, + [SMALL_STATE(817)] = 49955, + [SMALL_STATE(818)] = 49984, + [SMALL_STATE(819)] = 50005, + [SMALL_STATE(820)] = 50034, + [SMALL_STATE(821)] = 50069, + [SMALL_STATE(822)] = 50098, + [SMALL_STATE(823)] = 50119, + [SMALL_STATE(824)] = 50145, + [SMALL_STATE(825)] = 50171, + [SMALL_STATE(826)] = 50191, + [SMALL_STATE(827)] = 50217, + [SMALL_STATE(828)] = 50251, + [SMALL_STATE(829)] = 50283, + [SMALL_STATE(830)] = 50311, + [SMALL_STATE(831)] = 50337, + [SMALL_STATE(832)] = 50363, + [SMALL_STATE(833)] = 50389, + [SMALL_STATE(834)] = 50407, + [SMALL_STATE(835)] = 50433, + [SMALL_STATE(836)] = 50451, + [SMALL_STATE(837)] = 50477, + [SMALL_STATE(838)] = 50503, + [SMALL_STATE(839)] = 50521, + [SMALL_STATE(840)] = 50544, + [SMALL_STATE(841)] = 50567, + [SMALL_STATE(842)] = 50590, + [SMALL_STATE(843)] = 50605, + [SMALL_STATE(844)] = 50620, + [SMALL_STATE(845)] = 50643, + [SMALL_STATE(846)] = 50670, + [SMALL_STATE(847)] = 50693, + [SMALL_STATE(848)] = 50716, + [SMALL_STATE(849)] = 50739, + [SMALL_STATE(850)] = 50762, + [SMALL_STATE(851)] = 50785, + [SMALL_STATE(852)] = 50808, + [SMALL_STATE(853)] = 50831, + [SMALL_STATE(854)] = 50854, + [SMALL_STATE(855)] = 50877, + [SMALL_STATE(856)] = 50900, + [SMALL_STATE(857)] = 50923, + [SMALL_STATE(858)] = 50946, + [SMALL_STATE(859)] = 50961, + [SMALL_STATE(860)] = 50976, + [SMALL_STATE(861)] = 50999, + [SMALL_STATE(862)] = 51022, + [SMALL_STATE(863)] = 51045, + [SMALL_STATE(864)] = 51068, + [SMALL_STATE(865)] = 51091, + [SMALL_STATE(866)] = 51114, + [SMALL_STATE(867)] = 51133, + [SMALL_STATE(868)] = 51152, + [SMALL_STATE(869)] = 51175, + [SMALL_STATE(870)] = 51198, + [SMALL_STATE(871)] = 51221, + [SMALL_STATE(872)] = 51244, + [SMALL_STATE(873)] = 51267, + [SMALL_STATE(874)] = 51290, + [SMALL_STATE(875)] = 51313, + [SMALL_STATE(876)] = 51336, + [SMALL_STATE(877)] = 51359, + [SMALL_STATE(878)] = 51382, + [SMALL_STATE(879)] = 51405, + [SMALL_STATE(880)] = 51420, + [SMALL_STATE(881)] = 51435, + [SMALL_STATE(882)] = 51450, + [SMALL_STATE(883)] = 51465, + [SMALL_STATE(884)] = 51488, + [SMALL_STATE(885)] = 51511, + [SMALL_STATE(886)] = 51534, + [SMALL_STATE(887)] = 51557, + [SMALL_STATE(888)] = 51580, + [SMALL_STATE(889)] = 51603, + [SMALL_STATE(890)] = 51626, + [SMALL_STATE(891)] = 51649, + [SMALL_STATE(892)] = 51664, + [SMALL_STATE(893)] = 51687, + [SMALL_STATE(894)] = 51710, + [SMALL_STATE(895)] = 51725, + [SMALL_STATE(896)] = 51740, + [SMALL_STATE(897)] = 51763, + [SMALL_STATE(898)] = 51786, + [SMALL_STATE(899)] = 51801, + [SMALL_STATE(900)] = 51824, + [SMALL_STATE(901)] = 51847, + [SMALL_STATE(902)] = 51870, + [SMALL_STATE(903)] = 51893, + [SMALL_STATE(904)] = 51908, + [SMALL_STATE(905)] = 51931, + [SMALL_STATE(906)] = 51954, + [SMALL_STATE(907)] = 51977, + [SMALL_STATE(908)] = 52000, + [SMALL_STATE(909)] = 52015, + [SMALL_STATE(910)] = 52038, + [SMALL_STATE(911)] = 52061, + [SMALL_STATE(912)] = 52084, + [SMALL_STATE(913)] = 52107, + [SMALL_STATE(914)] = 52130, + [SMALL_STATE(915)] = 52153, + [SMALL_STATE(916)] = 52176, + [SMALL_STATE(917)] = 52199, + [SMALL_STATE(918)] = 52222, + [SMALL_STATE(919)] = 52245, + [SMALL_STATE(920)] = 52268, + [SMALL_STATE(921)] = 52291, + [SMALL_STATE(922)] = 52314, + [SMALL_STATE(923)] = 52329, + [SMALL_STATE(924)] = 52344, + [SMALL_STATE(925)] = 52367, + [SMALL_STATE(926)] = 52390, + [SMALL_STATE(927)] = 52413, + [SMALL_STATE(928)] = 52436, + [SMALL_STATE(929)] = 52459, + [SMALL_STATE(930)] = 52482, + [SMALL_STATE(931)] = 52497, + [SMALL_STATE(932)] = 52520, + [SMALL_STATE(933)] = 52535, + [SMALL_STATE(934)] = 52558, + [SMALL_STATE(935)] = 52573, + [SMALL_STATE(936)] = 52588, + [SMALL_STATE(937)] = 52611, + [SMALL_STATE(938)] = 52633, + [SMALL_STATE(939)] = 52647, + [SMALL_STATE(940)] = 52662, + [SMALL_STATE(941)] = 52677, + [SMALL_STATE(942)] = 52692, + [SMALL_STATE(943)] = 52707, + [SMALL_STATE(944)] = 52722, + [SMALL_STATE(945)] = 52737, + [SMALL_STATE(946)] = 52752, + [SMALL_STATE(947)] = 52767, + [SMALL_STATE(948)] = 52790, + [SMALL_STATE(949)] = 52805, + [SMALL_STATE(950)] = 52826, + [SMALL_STATE(951)] = 52841, + [SMALL_STATE(952)] = 52864, + [SMALL_STATE(953)] = 52885, + [SMALL_STATE(954)] = 52900, + [SMALL_STATE(955)] = 52921, + [SMALL_STATE(956)] = 52942, + [SMALL_STATE(957)] = 52963, + [SMALL_STATE(958)] = 52978, + [SMALL_STATE(959)] = 52999, + [SMALL_STATE(960)] = 53022, + [SMALL_STATE(961)] = 53043, + [SMALL_STATE(962)] = 53066, + [SMALL_STATE(963)] = 53087, + [SMALL_STATE(964)] = 53102, + [SMALL_STATE(965)] = 53117, + [SMALL_STATE(966)] = 53140, + [SMALL_STATE(967)] = 53155, + [SMALL_STATE(968)] = 53178, + [SMALL_STATE(969)] = 53193, + [SMALL_STATE(970)] = 53209, + [SMALL_STATE(971)] = 53231, + [SMALL_STATE(972)] = 53245, + [SMALL_STATE(973)] = 53263, + [SMALL_STATE(974)] = 53285, + [SMALL_STATE(975)] = 53307, + [SMALL_STATE(976)] = 53329, + [SMALL_STATE(977)] = 53351, + [SMALL_STATE(978)] = 53373, + [SMALL_STATE(979)] = 53395, + [SMALL_STATE(980)] = 53417, + [SMALL_STATE(981)] = 53437, + [SMALL_STATE(982)] = 53459, + [SMALL_STATE(983)] = 53481, + [SMALL_STATE(984)] = 53503, + [SMALL_STATE(985)] = 53525, + [SMALL_STATE(986)] = 53547, + [SMALL_STATE(987)] = 53559, + [SMALL_STATE(988)] = 53581, + [SMALL_STATE(989)] = 53603, + [SMALL_STATE(990)] = 53625, + [SMALL_STATE(991)] = 53642, + [SMALL_STATE(992)] = 53659, + [SMALL_STATE(993)] = 53676, + [SMALL_STATE(994)] = 53693, + [SMALL_STATE(995)] = 53712, + [SMALL_STATE(996)] = 53729, + [SMALL_STATE(997)] = 53746, + [SMALL_STATE(998)] = 53765, + [SMALL_STATE(999)] = 53784, + [SMALL_STATE(1000)] = 53801, + [SMALL_STATE(1001)] = 53818, + [SMALL_STATE(1002)] = 53835, + [SMALL_STATE(1003)] = 53852, + [SMALL_STATE(1004)] = 53869, + [SMALL_STATE(1005)] = 53888, + [SMALL_STATE(1006)] = 53903, + [SMALL_STATE(1007)] = 53920, + [SMALL_STATE(1008)] = 53937, + [SMALL_STATE(1009)] = 53954, + [SMALL_STATE(1010)] = 53973, + [SMALL_STATE(1011)] = 53992, + [SMALL_STATE(1012)] = 54009, + [SMALL_STATE(1013)] = 54028, + [SMALL_STATE(1014)] = 54045, + [SMALL_STATE(1015)] = 54062, + [SMALL_STATE(1016)] = 54079, + [SMALL_STATE(1017)] = 54098, + [SMALL_STATE(1018)] = 54117, + [SMALL_STATE(1019)] = 54134, + [SMALL_STATE(1020)] = 54151, + [SMALL_STATE(1021)] = 54170, + [SMALL_STATE(1022)] = 54187, + [SMALL_STATE(1023)] = 54206, + [SMALL_STATE(1024)] = 54223, + [SMALL_STATE(1025)] = 54240, + [SMALL_STATE(1026)] = 54257, + [SMALL_STATE(1027)] = 54274, + [SMALL_STATE(1028)] = 54293, + [SMALL_STATE(1029)] = 54312, + [SMALL_STATE(1030)] = 54331, + [SMALL_STATE(1031)] = 54350, + [SMALL_STATE(1032)] = 54365, + [SMALL_STATE(1033)] = 54384, + [SMALL_STATE(1034)] = 54401, + [SMALL_STATE(1035)] = 54418, + [SMALL_STATE(1036)] = 54435, + [SMALL_STATE(1037)] = 54452, + [SMALL_STATE(1038)] = 54469, + [SMALL_STATE(1039)] = 54488, + [SMALL_STATE(1040)] = 54505, + [SMALL_STATE(1041)] = 54524, + [SMALL_STATE(1042)] = 54541, + [SMALL_STATE(1043)] = 54558, + [SMALL_STATE(1044)] = 54575, + [SMALL_STATE(1045)] = 54592, + [SMALL_STATE(1046)] = 54609, + [SMALL_STATE(1047)] = 54626, + [SMALL_STATE(1048)] = 54645, + [SMALL_STATE(1049)] = 54662, + [SMALL_STATE(1050)] = 54679, + [SMALL_STATE(1051)] = 54696, + [SMALL_STATE(1052)] = 54713, + [SMALL_STATE(1053)] = 54732, + [SMALL_STATE(1054)] = 54751, + [SMALL_STATE(1055)] = 54770, + [SMALL_STATE(1056)] = 54784, + [SMALL_STATE(1057)] = 54798, + [SMALL_STATE(1058)] = 54812, + [SMALL_STATE(1059)] = 54826, + [SMALL_STATE(1060)] = 54842, + [SMALL_STATE(1061)] = 54856, + [SMALL_STATE(1062)] = 54872, + [SMALL_STATE(1063)] = 54886, + [SMALL_STATE(1064)] = 54900, + [SMALL_STATE(1065)] = 54914, + [SMALL_STATE(1066)] = 54928, + [SMALL_STATE(1067)] = 54944, + [SMALL_STATE(1068)] = 54960, + [SMALL_STATE(1069)] = 54974, + [SMALL_STATE(1070)] = 54984, + [SMALL_STATE(1071)] = 54998, + [SMALL_STATE(1072)] = 55012, + [SMALL_STATE(1073)] = 55028, + [SMALL_STATE(1074)] = 55044, + [SMALL_STATE(1075)] = 55060, + [SMALL_STATE(1076)] = 55074, + [SMALL_STATE(1077)] = 55088, + [SMALL_STATE(1078)] = 55102, + [SMALL_STATE(1079)] = 55114, + [SMALL_STATE(1080)] = 55130, + [SMALL_STATE(1081)] = 55144, + [SMALL_STATE(1082)] = 55154, + [SMALL_STATE(1083)] = 55164, + [SMALL_STATE(1084)] = 55178, + [SMALL_STATE(1085)] = 55192, + [SMALL_STATE(1086)] = 55202, + [SMALL_STATE(1087)] = 55212, + [SMALL_STATE(1088)] = 55226, + [SMALL_STATE(1089)] = 55240, + [SMALL_STATE(1090)] = 55250, + [SMALL_STATE(1091)] = 55266, + [SMALL_STATE(1092)] = 55276, + [SMALL_STATE(1093)] = 55290, + [SMALL_STATE(1094)] = 55300, + [SMALL_STATE(1095)] = 55314, + [SMALL_STATE(1096)] = 55324, + [SMALL_STATE(1097)] = 55334, + [SMALL_STATE(1098)] = 55350, + [SMALL_STATE(1099)] = 55364, + [SMALL_STATE(1100)] = 55374, + [SMALL_STATE(1101)] = 55388, + [SMALL_STATE(1102)] = 55402, + [SMALL_STATE(1103)] = 55416, + [SMALL_STATE(1104)] = 55426, + [SMALL_STATE(1105)] = 55440, + [SMALL_STATE(1106)] = 55454, + [SMALL_STATE(1107)] = 55468, + [SMALL_STATE(1108)] = 55484, + [SMALL_STATE(1109)] = 55494, + [SMALL_STATE(1110)] = 55508, + [SMALL_STATE(1111)] = 55524, + [SMALL_STATE(1112)] = 55540, + [SMALL_STATE(1113)] = 55550, + [SMALL_STATE(1114)] = 55566, + [SMALL_STATE(1115)] = 55580, + [SMALL_STATE(1116)] = 55590, + [SMALL_STATE(1117)] = 55600, + [SMALL_STATE(1118)] = 55614, + [SMALL_STATE(1119)] = 55627, + [SMALL_STATE(1120)] = 55640, + [SMALL_STATE(1121)] = 55653, + [SMALL_STATE(1122)] = 55666, + [SMALL_STATE(1123)] = 55675, + [SMALL_STATE(1124)] = 55686, + [SMALL_STATE(1125)] = 55699, + [SMALL_STATE(1126)] = 55712, + [SMALL_STATE(1127)] = 55725, + [SMALL_STATE(1128)] = 55738, + [SMALL_STATE(1129)] = 55751, + [SMALL_STATE(1130)] = 55760, + [SMALL_STATE(1131)] = 55773, + [SMALL_STATE(1132)] = 55786, + [SMALL_STATE(1133)] = 55799, + [SMALL_STATE(1134)] = 55812, + [SMALL_STATE(1135)] = 55825, + [SMALL_STATE(1136)] = 55838, + [SMALL_STATE(1137)] = 55851, + [SMALL_STATE(1138)] = 55864, + [SMALL_STATE(1139)] = 55877, + [SMALL_STATE(1140)] = 55890, + [SMALL_STATE(1141)] = 55903, + [SMALL_STATE(1142)] = 55916, + [SMALL_STATE(1143)] = 55929, + [SMALL_STATE(1144)] = 55942, + [SMALL_STATE(1145)] = 55955, + [SMALL_STATE(1146)] = 55968, + [SMALL_STATE(1147)] = 55981, + [SMALL_STATE(1148)] = 55994, + [SMALL_STATE(1149)] = 56007, + [SMALL_STATE(1150)] = 56020, + [SMALL_STATE(1151)] = 56033, + [SMALL_STATE(1152)] = 56046, + [SMALL_STATE(1153)] = 56059, + [SMALL_STATE(1154)] = 56072, + [SMALL_STATE(1155)] = 56083, + [SMALL_STATE(1156)] = 56096, + [SMALL_STATE(1157)] = 56109, + [SMALL_STATE(1158)] = 56122, + [SMALL_STATE(1159)] = 56135, + [SMALL_STATE(1160)] = 56148, + [SMALL_STATE(1161)] = 56161, + [SMALL_STATE(1162)] = 56174, + [SMALL_STATE(1163)] = 56187, + [SMALL_STATE(1164)] = 56200, + [SMALL_STATE(1165)] = 56213, + [SMALL_STATE(1166)] = 56226, + [SMALL_STATE(1167)] = 56239, + [SMALL_STATE(1168)] = 56252, + [SMALL_STATE(1169)] = 56265, + [SMALL_STATE(1170)] = 56278, + [SMALL_STATE(1171)] = 56291, + [SMALL_STATE(1172)] = 56304, + [SMALL_STATE(1173)] = 56317, + [SMALL_STATE(1174)] = 56330, + [SMALL_STATE(1175)] = 56343, + [SMALL_STATE(1176)] = 56356, + [SMALL_STATE(1177)] = 56369, + [SMALL_STATE(1178)] = 56382, + [SMALL_STATE(1179)] = 56395, + [SMALL_STATE(1180)] = 56408, + [SMALL_STATE(1181)] = 56421, + [SMALL_STATE(1182)] = 56434, + [SMALL_STATE(1183)] = 56447, + [SMALL_STATE(1184)] = 56460, + [SMALL_STATE(1185)] = 56473, + [SMALL_STATE(1186)] = 56486, + [SMALL_STATE(1187)] = 56499, + [SMALL_STATE(1188)] = 56510, + [SMALL_STATE(1189)] = 56523, + [SMALL_STATE(1190)] = 56536, + [SMALL_STATE(1191)] = 56549, + [SMALL_STATE(1192)] = 56562, + [SMALL_STATE(1193)] = 56573, + [SMALL_STATE(1194)] = 56586, + [SMALL_STATE(1195)] = 56597, + [SMALL_STATE(1196)] = 56610, + [SMALL_STATE(1197)] = 56623, + [SMALL_STATE(1198)] = 56636, + [SMALL_STATE(1199)] = 56649, + [SMALL_STATE(1200)] = 56662, + [SMALL_STATE(1201)] = 56675, + [SMALL_STATE(1202)] = 56688, + [SMALL_STATE(1203)] = 56699, + [SMALL_STATE(1204)] = 56712, + [SMALL_STATE(1205)] = 56725, + [SMALL_STATE(1206)] = 56738, + [SMALL_STATE(1207)] = 56751, + [SMALL_STATE(1208)] = 56764, + [SMALL_STATE(1209)] = 56777, + [SMALL_STATE(1210)] = 56788, + [SMALL_STATE(1211)] = 56801, + [SMALL_STATE(1212)] = 56814, + [SMALL_STATE(1213)] = 56827, + [SMALL_STATE(1214)] = 56840, + [SMALL_STATE(1215)] = 56853, + [SMALL_STATE(1216)] = 56864, + [SMALL_STATE(1217)] = 56877, + [SMALL_STATE(1218)] = 56890, + [SMALL_STATE(1219)] = 56899, + [SMALL_STATE(1220)] = 56912, + [SMALL_STATE(1221)] = 56921, + [SMALL_STATE(1222)] = 56934, + [SMALL_STATE(1223)] = 56947, + [SMALL_STATE(1224)] = 56960, + [SMALL_STATE(1225)] = 56973, + [SMALL_STATE(1226)] = 56984, + [SMALL_STATE(1227)] = 56997, + [SMALL_STATE(1228)] = 57008, + [SMALL_STATE(1229)] = 57021, + [SMALL_STATE(1230)] = 57034, + [SMALL_STATE(1231)] = 57043, + [SMALL_STATE(1232)] = 57056, + [SMALL_STATE(1233)] = 57069, + [SMALL_STATE(1234)] = 57082, + [SMALL_STATE(1235)] = 57095, + [SMALL_STATE(1236)] = 57108, + [SMALL_STATE(1237)] = 57119, + [SMALL_STATE(1238)] = 57128, + [SMALL_STATE(1239)] = 57141, + [SMALL_STATE(1240)] = 57152, + [SMALL_STATE(1241)] = 57165, + [SMALL_STATE(1242)] = 57178, + [SMALL_STATE(1243)] = 57187, + [SMALL_STATE(1244)] = 57198, + [SMALL_STATE(1245)] = 57211, + [SMALL_STATE(1246)] = 57224, + [SMALL_STATE(1247)] = 57237, + [SMALL_STATE(1248)] = 57250, + [SMALL_STATE(1249)] = 57263, + [SMALL_STATE(1250)] = 57276, + [SMALL_STATE(1251)] = 57285, + [SMALL_STATE(1252)] = 57298, + [SMALL_STATE(1253)] = 57311, + [SMALL_STATE(1254)] = 57324, + [SMALL_STATE(1255)] = 57337, + [SMALL_STATE(1256)] = 57350, + [SMALL_STATE(1257)] = 57363, + [SMALL_STATE(1258)] = 57376, + [SMALL_STATE(1259)] = 57389, + [SMALL_STATE(1260)] = 57402, + [SMALL_STATE(1261)] = 57415, + [SMALL_STATE(1262)] = 57426, + [SMALL_STATE(1263)] = 57436, + [SMALL_STATE(1264)] = 57446, + [SMALL_STATE(1265)] = 57454, + [SMALL_STATE(1266)] = 57464, + [SMALL_STATE(1267)] = 57474, + [SMALL_STATE(1268)] = 57484, + [SMALL_STATE(1269)] = 57492, + [SMALL_STATE(1270)] = 57502, + [SMALL_STATE(1271)] = 57512, + [SMALL_STATE(1272)] = 57522, + [SMALL_STATE(1273)] = 57530, + [SMALL_STATE(1274)] = 57540, + [SMALL_STATE(1275)] = 57548, + [SMALL_STATE(1276)] = 57558, + [SMALL_STATE(1277)] = 57566, + [SMALL_STATE(1278)] = 57574, + [SMALL_STATE(1279)] = 57582, + [SMALL_STATE(1280)] = 57590, + [SMALL_STATE(1281)] = 57598, + [SMALL_STATE(1282)] = 57606, + [SMALL_STATE(1283)] = 57616, + [SMALL_STATE(1284)] = 57626, + [SMALL_STATE(1285)] = 57634, + [SMALL_STATE(1286)] = 57644, + [SMALL_STATE(1287)] = 57654, + [SMALL_STATE(1288)] = 57664, + [SMALL_STATE(1289)] = 57672, + [SMALL_STATE(1290)] = 57680, + [SMALL_STATE(1291)] = 57690, + [SMALL_STATE(1292)] = 57700, + [SMALL_STATE(1293)] = 57708, + [SMALL_STATE(1294)] = 57718, + [SMALL_STATE(1295)] = 57726, + [SMALL_STATE(1296)] = 57734, + [SMALL_STATE(1297)] = 57742, + [SMALL_STATE(1298)] = 57752, + [SMALL_STATE(1299)] = 57762, + [SMALL_STATE(1300)] = 57772, + [SMALL_STATE(1301)] = 57782, + [SMALL_STATE(1302)] = 57792, + [SMALL_STATE(1303)] = 57802, + [SMALL_STATE(1304)] = 57812, + [SMALL_STATE(1305)] = 57822, + [SMALL_STATE(1306)] = 57832, + [SMALL_STATE(1307)] = 57842, + [SMALL_STATE(1308)] = 57852, + [SMALL_STATE(1309)] = 57862, + [SMALL_STATE(1310)] = 57870, + [SMALL_STATE(1311)] = 57878, + [SMALL_STATE(1312)] = 57888, + [SMALL_STATE(1313)] = 57896, + [SMALL_STATE(1314)] = 57906, + [SMALL_STATE(1315)] = 57916, + [SMALL_STATE(1316)] = 57924, + [SMALL_STATE(1317)] = 57934, + [SMALL_STATE(1318)] = 57944, + [SMALL_STATE(1319)] = 57952, + [SMALL_STATE(1320)] = 57962, + [SMALL_STATE(1321)] = 57972, + [SMALL_STATE(1322)] = 57982, + [SMALL_STATE(1323)] = 57992, + [SMALL_STATE(1324)] = 58002, + [SMALL_STATE(1325)] = 58012, + [SMALL_STATE(1326)] = 58022, + [SMALL_STATE(1327)] = 58032, + [SMALL_STATE(1328)] = 58042, + [SMALL_STATE(1329)] = 58052, + [SMALL_STATE(1330)] = 58060, + [SMALL_STATE(1331)] = 58070, + [SMALL_STATE(1332)] = 58078, + [SMALL_STATE(1333)] = 58088, + [SMALL_STATE(1334)] = 58098, + [SMALL_STATE(1335)] = 58108, + [SMALL_STATE(1336)] = 58118, + [SMALL_STATE(1337)] = 58128, + [SMALL_STATE(1338)] = 58138, + [SMALL_STATE(1339)] = 58148, + [SMALL_STATE(1340)] = 58158, + [SMALL_STATE(1341)] = 58168, + [SMALL_STATE(1342)] = 58178, + [SMALL_STATE(1343)] = 58188, + [SMALL_STATE(1344)] = 58196, + [SMALL_STATE(1345)] = 58204, + [SMALL_STATE(1346)] = 58214, + [SMALL_STATE(1347)] = 58222, + [SMALL_STATE(1348)] = 58232, + [SMALL_STATE(1349)] = 58242, + [SMALL_STATE(1350)] = 58252, + [SMALL_STATE(1351)] = 58262, + [SMALL_STATE(1352)] = 58272, + [SMALL_STATE(1353)] = 58282, + [SMALL_STATE(1354)] = 58290, + [SMALL_STATE(1355)] = 58300, + [SMALL_STATE(1356)] = 58310, + [SMALL_STATE(1357)] = 58320, + [SMALL_STATE(1358)] = 58330, + [SMALL_STATE(1359)] = 58340, + [SMALL_STATE(1360)] = 58348, + [SMALL_STATE(1361)] = 58355, + [SMALL_STATE(1362)] = 58362, + [SMALL_STATE(1363)] = 58369, + [SMALL_STATE(1364)] = 58376, + [SMALL_STATE(1365)] = 58383, + [SMALL_STATE(1366)] = 58390, + [SMALL_STATE(1367)] = 58397, + [SMALL_STATE(1368)] = 58404, + [SMALL_STATE(1369)] = 58411, + [SMALL_STATE(1370)] = 58418, + [SMALL_STATE(1371)] = 58425, + [SMALL_STATE(1372)] = 58432, + [SMALL_STATE(1373)] = 58439, + [SMALL_STATE(1374)] = 58446, + [SMALL_STATE(1375)] = 58453, + [SMALL_STATE(1376)] = 58460, + [SMALL_STATE(1377)] = 58467, + [SMALL_STATE(1378)] = 58474, + [SMALL_STATE(1379)] = 58481, + [SMALL_STATE(1380)] = 58488, + [SMALL_STATE(1381)] = 58495, + [SMALL_STATE(1382)] = 58502, + [SMALL_STATE(1383)] = 58509, + [SMALL_STATE(1384)] = 58516, + [SMALL_STATE(1385)] = 58523, + [SMALL_STATE(1386)] = 58530, + [SMALL_STATE(1387)] = 58537, + [SMALL_STATE(1388)] = 58544, + [SMALL_STATE(1389)] = 58551, + [SMALL_STATE(1390)] = 58558, + [SMALL_STATE(1391)] = 58565, + [SMALL_STATE(1392)] = 58572, + [SMALL_STATE(1393)] = 58579, + [SMALL_STATE(1394)] = 58586, + [SMALL_STATE(1395)] = 58593, + [SMALL_STATE(1396)] = 58600, + [SMALL_STATE(1397)] = 58607, + [SMALL_STATE(1398)] = 58614, + [SMALL_STATE(1399)] = 58621, + [SMALL_STATE(1400)] = 58628, + [SMALL_STATE(1401)] = 58635, + [SMALL_STATE(1402)] = 58642, + [SMALL_STATE(1403)] = 58649, + [SMALL_STATE(1404)] = 58656, + [SMALL_STATE(1405)] = 58663, + [SMALL_STATE(1406)] = 58670, + [SMALL_STATE(1407)] = 58677, + [SMALL_STATE(1408)] = 58684, + [SMALL_STATE(1409)] = 58691, + [SMALL_STATE(1410)] = 58698, + [SMALL_STATE(1411)] = 58705, + [SMALL_STATE(1412)] = 58712, + [SMALL_STATE(1413)] = 58719, + [SMALL_STATE(1414)] = 58726, + [SMALL_STATE(1415)] = 58733, + [SMALL_STATE(1416)] = 58740, + [SMALL_STATE(1417)] = 58747, + [SMALL_STATE(1418)] = 58754, + [SMALL_STATE(1419)] = 58761, + [SMALL_STATE(1420)] = 58768, + [SMALL_STATE(1421)] = 58775, + [SMALL_STATE(1422)] = 58782, + [SMALL_STATE(1423)] = 58789, + [SMALL_STATE(1424)] = 58796, + [SMALL_STATE(1425)] = 58803, + [SMALL_STATE(1426)] = 58810, + [SMALL_STATE(1427)] = 58817, + [SMALL_STATE(1428)] = 58824, + [SMALL_STATE(1429)] = 58831, + [SMALL_STATE(1430)] = 58838, + [SMALL_STATE(1431)] = 58845, + [SMALL_STATE(1432)] = 58852, + [SMALL_STATE(1433)] = 58859, + [SMALL_STATE(1434)] = 58866, + [SMALL_STATE(1435)] = 58873, + [SMALL_STATE(1436)] = 58880, + [SMALL_STATE(1437)] = 58887, + [SMALL_STATE(1438)] = 58894, + [SMALL_STATE(1439)] = 58901, + [SMALL_STATE(1440)] = 58908, + [SMALL_STATE(1441)] = 58915, + [SMALL_STATE(1442)] = 58922, + [SMALL_STATE(1443)] = 58929, + [SMALL_STATE(1444)] = 58936, + [SMALL_STATE(1445)] = 58943, + [SMALL_STATE(1446)] = 58950, + [SMALL_STATE(1447)] = 58957, + [SMALL_STATE(1448)] = 58964, + [SMALL_STATE(1449)] = 58971, + [SMALL_STATE(1450)] = 58978, + [SMALL_STATE(1451)] = 58985, + [SMALL_STATE(1452)] = 58992, + [SMALL_STATE(1453)] = 58999, + [SMALL_STATE(1454)] = 59006, + [SMALL_STATE(1455)] = 59013, + [SMALL_STATE(1456)] = 59020, + [SMALL_STATE(1457)] = 59027, + [SMALL_STATE(1458)] = 59034, + [SMALL_STATE(1459)] = 59041, + [SMALL_STATE(1460)] = 59048, + [SMALL_STATE(1461)] = 59055, + [SMALL_STATE(1462)] = 59062, + [SMALL_STATE(1463)] = 59069, + [SMALL_STATE(1464)] = 59076, + [SMALL_STATE(1465)] = 59083, + [SMALL_STATE(1466)] = 59090, + [SMALL_STATE(1467)] = 59097, + [SMALL_STATE(1468)] = 59104, + [SMALL_STATE(1469)] = 59111, + [SMALL_STATE(1470)] = 59118, + [SMALL_STATE(1471)] = 59125, + [SMALL_STATE(1472)] = 59132, + [SMALL_STATE(1473)] = 59139, + [SMALL_STATE(1474)] = 59146, + [SMALL_STATE(1475)] = 59153, + [SMALL_STATE(1476)] = 59160, + [SMALL_STATE(1477)] = 59167, + [SMALL_STATE(1478)] = 59174, + [SMALL_STATE(1479)] = 59181, + [SMALL_STATE(1480)] = 59188, + [SMALL_STATE(1481)] = 59195, + [SMALL_STATE(1482)] = 59202, + [SMALL_STATE(1483)] = 59209, + [SMALL_STATE(1484)] = 59216, + [SMALL_STATE(1485)] = 59223, + [SMALL_STATE(1486)] = 59230, + [SMALL_STATE(1487)] = 59237, + [SMALL_STATE(1488)] = 59244, + [SMALL_STATE(1489)] = 59251, + [SMALL_STATE(1490)] = 59258, + [SMALL_STATE(1491)] = 59265, + [SMALL_STATE(1492)] = 59272, + [SMALL_STATE(1493)] = 59279, + [SMALL_STATE(1494)] = 59286, + [SMALL_STATE(1495)] = 59293, + [SMALL_STATE(1496)] = 59300, + [SMALL_STATE(1497)] = 59307, + [SMALL_STATE(1498)] = 59314, + [SMALL_STATE(1499)] = 59321, + [SMALL_STATE(1500)] = 59328, + [SMALL_STATE(1501)] = 59335, + [SMALL_STATE(1502)] = 59342, + [SMALL_STATE(1503)] = 59349, + [SMALL_STATE(1504)] = 59356, + [SMALL_STATE(1505)] = 59363, + [SMALL_STATE(1506)] = 59370, + [SMALL_STATE(1507)] = 59377, + [SMALL_STATE(1508)] = 59384, + [SMALL_STATE(1509)] = 59391, + [SMALL_STATE(1510)] = 59398, + [SMALL_STATE(1511)] = 59405, + [SMALL_STATE(1512)] = 59412, + [SMALL_STATE(1513)] = 59419, + [SMALL_STATE(1514)] = 59426, + [SMALL_STATE(1515)] = 59433, + [SMALL_STATE(1516)] = 59440, + [SMALL_STATE(1517)] = 59447, + [SMALL_STATE(1518)] = 59454, + [SMALL_STATE(1519)] = 59461, + [SMALL_STATE(1520)] = 59468, + [SMALL_STATE(1521)] = 59475, + [SMALL_STATE(1522)] = 59482, + [SMALL_STATE(1523)] = 59489, + [SMALL_STATE(1524)] = 59496, + [SMALL_STATE(1525)] = 59503, + [SMALL_STATE(1526)] = 59510, + [SMALL_STATE(1527)] = 59517, + [SMALL_STATE(1528)] = 59524, + [SMALL_STATE(1529)] = 59531, + [SMALL_STATE(1530)] = 59538, + [SMALL_STATE(1531)] = 59545, + [SMALL_STATE(1532)] = 59552, + [SMALL_STATE(1533)] = 59559, + [SMALL_STATE(1534)] = 59566, + [SMALL_STATE(1535)] = 59573, + [SMALL_STATE(1536)] = 59580, + [SMALL_STATE(1537)] = 59587, + [SMALL_STATE(1538)] = 59594, + [SMALL_STATE(1539)] = 59601, + [SMALL_STATE(1540)] = 59608, + [SMALL_STATE(1541)] = 59615, + [SMALL_STATE(1542)] = 59622, + [SMALL_STATE(1543)] = 59629, + [SMALL_STATE(1544)] = 59636, + [SMALL_STATE(1545)] = 59643, + [SMALL_STATE(1546)] = 59650, + [SMALL_STATE(1547)] = 59657, + [SMALL_STATE(1548)] = 59664, + [SMALL_STATE(1549)] = 59671, + [SMALL_STATE(1550)] = 59678, + [SMALL_STATE(1551)] = 59685, + [SMALL_STATE(1552)] = 59692, + [SMALL_STATE(1553)] = 59699, + [SMALL_STATE(1554)] = 59706, + [SMALL_STATE(1555)] = 59713, + [SMALL_STATE(1556)] = 59720, + [SMALL_STATE(1557)] = 59727, + [SMALL_STATE(1558)] = 59734, + [SMALL_STATE(1559)] = 59741, + [SMALL_STATE(1560)] = 59748, + [SMALL_STATE(1561)] = 59755, + [SMALL_STATE(1562)] = 59762, + [SMALL_STATE(1563)] = 59769, + [SMALL_STATE(1564)] = 59776, + [SMALL_STATE(1565)] = 59783, + [SMALL_STATE(1566)] = 59790, + [SMALL_STATE(1567)] = 59797, + [SMALL_STATE(1568)] = 59804, + [SMALL_STATE(1569)] = 59811, + [SMALL_STATE(1570)] = 59818, + [SMALL_STATE(1571)] = 59825, + [SMALL_STATE(1572)] = 59832, + [SMALL_STATE(1573)] = 59839, + [SMALL_STATE(1574)] = 59846, + [SMALL_STATE(1575)] = 59853, + [SMALL_STATE(1576)] = 59860, + [SMALL_STATE(1577)] = 59867, + [SMALL_STATE(1578)] = 59874, + [SMALL_STATE(1579)] = 59881, + [SMALL_STATE(1580)] = 59888, + [SMALL_STATE(1581)] = 59895, + [SMALL_STATE(1582)] = 59902, + [SMALL_STATE(1583)] = 59909, + [SMALL_STATE(1584)] = 59916, + [SMALL_STATE(1585)] = 59923, + [SMALL_STATE(1586)] = 59930, + [SMALL_STATE(1587)] = 59937, + [SMALL_STATE(1588)] = 59944, + [SMALL_STATE(1589)] = 59951, + [SMALL_STATE(1590)] = 59958, + [SMALL_STATE(1591)] = 59965, + [SMALL_STATE(1592)] = 59972, + [SMALL_STATE(1593)] = 59979, + [SMALL_STATE(1594)] = 59986, + [SMALL_STATE(1595)] = 59993, + [SMALL_STATE(1596)] = 60000, + [SMALL_STATE(1597)] = 60007, + [SMALL_STATE(1598)] = 60014, + [SMALL_STATE(1599)] = 60021, + [SMALL_STATE(1600)] = 60028, + [SMALL_STATE(1601)] = 60035, + [SMALL_STATE(1602)] = 60042, + [SMALL_STATE(1603)] = 60049, + [SMALL_STATE(1604)] = 60056, + [SMALL_STATE(1605)] = 60063, + [SMALL_STATE(1606)] = 60070, + [SMALL_STATE(1607)] = 60077, + [SMALL_STATE(1608)] = 60084, + [SMALL_STATE(1609)] = 60091, + [SMALL_STATE(1610)] = 60098, + [SMALL_STATE(1611)] = 60105, + [SMALL_STATE(1612)] = 60112, + [SMALL_STATE(1613)] = 60119, + [SMALL_STATE(1614)] = 60126, + [SMALL_STATE(1615)] = 60133, + [SMALL_STATE(1616)] = 60140, + [SMALL_STATE(1617)] = 60147, + [SMALL_STATE(1618)] = 60154, + [SMALL_STATE(1619)] = 60161, + [SMALL_STATE(1620)] = 60168, + [SMALL_STATE(1621)] = 60175, + [SMALL_STATE(1622)] = 60182, + [SMALL_STATE(1623)] = 60189, + [SMALL_STATE(1624)] = 60196, + [SMALL_STATE(1625)] = 60203, + [SMALL_STATE(1626)] = 60210, + [SMALL_STATE(1627)] = 60217, + [SMALL_STATE(1628)] = 60224, + [SMALL_STATE(1629)] = 60231, + [SMALL_STATE(1630)] = 60238, + [SMALL_STATE(1631)] = 60245, + [SMALL_STATE(1632)] = 60252, + [SMALL_STATE(1633)] = 60259, + [SMALL_STATE(1634)] = 60266, + [SMALL_STATE(1635)] = 60273, + [SMALL_STATE(1636)] = 60280, + [SMALL_STATE(1637)] = 60287, + [SMALL_STATE(1638)] = 60294, + [SMALL_STATE(1639)] = 60301, + [SMALL_STATE(1640)] = 60308, + [SMALL_STATE(1641)] = 60315, + [SMALL_STATE(1642)] = 60322, + [SMALL_STATE(1643)] = 60329, + [SMALL_STATE(1644)] = 60336, + [SMALL_STATE(1645)] = 60343, + [SMALL_STATE(1646)] = 60350, + [SMALL_STATE(1647)] = 60357, + [SMALL_STATE(1648)] = 60364, + [SMALL_STATE(1649)] = 60371, + [SMALL_STATE(1650)] = 60378, + [SMALL_STATE(1651)] = 60385, + [SMALL_STATE(1652)] = 60392, + [SMALL_STATE(1653)] = 60399, + [SMALL_STATE(1654)] = 60406, + [SMALL_STATE(1655)] = 60413, + [SMALL_STATE(1656)] = 60420, + [SMALL_STATE(1657)] = 60427, + [SMALL_STATE(1658)] = 60434, + [SMALL_STATE(1659)] = 60441, + [SMALL_STATE(1660)] = 60448, + [SMALL_STATE(1661)] = 60455, + [SMALL_STATE(1662)] = 60462, + [SMALL_STATE(1663)] = 60469, + [SMALL_STATE(1664)] = 60476, + [SMALL_STATE(1665)] = 60483, + [SMALL_STATE(1666)] = 60490, + [SMALL_STATE(1667)] = 60497, + [SMALL_STATE(1668)] = 60504, + [SMALL_STATE(1669)] = 60511, + [SMALL_STATE(1670)] = 60518, + [SMALL_STATE(1671)] = 60525, + [SMALL_STATE(1672)] = 60532, + [SMALL_STATE(1673)] = 60539, + [SMALL_STATE(1674)] = 60546, + [SMALL_STATE(1675)] = 60553, + [SMALL_STATE(1676)] = 60560, + [SMALL_STATE(1677)] = 60567, + [SMALL_STATE(1678)] = 60574, + [SMALL_STATE(1679)] = 60581, + [SMALL_STATE(1680)] = 60588, + [SMALL_STATE(1681)] = 60595, + [SMALL_STATE(1682)] = 60602, + [SMALL_STATE(1683)] = 60609, + [SMALL_STATE(1684)] = 60616, + [SMALL_STATE(1685)] = 60623, + [SMALL_STATE(1686)] = 60630, + [SMALL_STATE(1687)] = 60637, + [SMALL_STATE(1688)] = 60644, + [SMALL_STATE(1689)] = 60651, + [SMALL_STATE(1690)] = 60658, + [SMALL_STATE(1691)] = 60665, + [SMALL_STATE(1692)] = 60672, + [SMALL_STATE(1693)] = 60679, + [SMALL_STATE(1694)] = 60686, + [SMALL_STATE(1695)] = 60693, + [SMALL_STATE(1696)] = 60700, + [SMALL_STATE(1697)] = 60707, + [SMALL_STATE(1698)] = 60714, + [SMALL_STATE(1699)] = 60721, + [SMALL_STATE(1700)] = 60728, + [SMALL_STATE(1701)] = 60735, + [SMALL_STATE(1702)] = 60742, + [SMALL_STATE(1703)] = 60749, + [SMALL_STATE(1704)] = 60756, + [SMALL_STATE(1705)] = 60763, + [SMALL_STATE(1706)] = 60770, + [SMALL_STATE(1707)] = 60777, + [SMALL_STATE(1708)] = 60784, + [SMALL_STATE(1709)] = 60791, + [SMALL_STATE(1710)] = 60798, + [SMALL_STATE(1711)] = 60805, + [SMALL_STATE(1712)] = 60812, + [SMALL_STATE(1713)] = 60819, + [SMALL_STATE(1714)] = 60826, + [SMALL_STATE(1715)] = 60833, + [SMALL_STATE(1716)] = 60840, + [SMALL_STATE(1717)] = 60847, + [SMALL_STATE(1718)] = 60854, + [SMALL_STATE(1719)] = 60861, + [SMALL_STATE(1720)] = 60868, + [SMALL_STATE(1721)] = 60875, + [SMALL_STATE(1722)] = 60882, + [SMALL_STATE(1723)] = 60889, + [SMALL_STATE(1724)] = 60896, + [SMALL_STATE(1725)] = 60903, + [SMALL_STATE(1726)] = 60910, + [SMALL_STATE(1727)] = 60917, + [SMALL_STATE(1728)] = 60924, + [SMALL_STATE(1729)] = 60931, + [SMALL_STATE(1730)] = 60938, + [SMALL_STATE(1731)] = 60945, + [SMALL_STATE(1732)] = 60952, + [SMALL_STATE(1733)] = 60959, + [SMALL_STATE(1734)] = 60966, + [SMALL_STATE(1735)] = 60973, + [SMALL_STATE(1736)] = 60980, + [SMALL_STATE(1737)] = 60987, + [SMALL_STATE(1738)] = 60994, + [SMALL_STATE(1739)] = 61001, + [SMALL_STATE(1740)] = 61008, + [SMALL_STATE(1741)] = 61015, + [SMALL_STATE(1742)] = 61022, + [SMALL_STATE(1743)] = 61029, + [SMALL_STATE(1744)] = 61036, + [SMALL_STATE(1745)] = 61043, + [SMALL_STATE(1746)] = 61050, + [SMALL_STATE(1747)] = 61057, + [SMALL_STATE(1748)] = 61064, + [SMALL_STATE(1749)] = 61071, + [SMALL_STATE(1750)] = 61078, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -55667,1575 +57373,1597 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(429), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(981), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(410), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1016), [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1206), - [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1479), - [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1268), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1570), - [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1427), - [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1602), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1646), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(185), - [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1132), - [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1134), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1477), - [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(195), - [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1225), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1729), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1285), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1602), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1706), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1479), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1555), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1179), + [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1243), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1656), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), - [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1356), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1370), - [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1262), - [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1378), - [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1379), - [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), - [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1460), - [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(463), - [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), - [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), - [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), - [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), - [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), - [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), - [81] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), - [83] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(429), - [86] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(981), - [89] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(2), - [92] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1206), - [95] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1479), - [98] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1268), - [101] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(139), - [104] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1570), - [107] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1427), - [110] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), - [113] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1602), - [116] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1646), - [119] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(157), - [122] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(30), - [125] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(185), - [128] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(188), - [131] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1132), - [134] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1134), - [137] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1477), - [140] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(195), - [143] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(51), - [146] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), - [149] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1356), - [152] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1370), - [155] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1262), - [158] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1378), - [161] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1379), - [164] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), - [167] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1460), - [170] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(463), - [173] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(489), - [176] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(489), - [179] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(224), - [182] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), - [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), - [186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), - [188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), - [190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), - [192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(247), - [196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), - [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [200] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), - [202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1649), - [204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [206] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1038), - [208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(189), - [210] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), - [212] = {.entry = {.count = 1, .reusable = false}}, SHIFT(216), - [214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), - [216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1235), - [218] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1221), - [220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1678), - [222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190), - [226] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), - [228] = {.entry = {.count = 1, .reusable = false}}, SHIFT(13), - [230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1718), - [232] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1679), - [234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1342), - [236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1607), - [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(354), - [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), - [242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(379), - [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), - [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), - [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), - [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), - [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(227), - [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1523), - [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(992), - [262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), - [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), - [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(215), - [268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(221), - [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1232), - [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1205), - [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1644), - [276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), - [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1530), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1549), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1313), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1557), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1587), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1290), + [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1626), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(475), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(477), + [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(399), + [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(292), + [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), + [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [87] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1675), + [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1018), + [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(218), + [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1248), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1227), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1704), + [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193), + [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(194), + [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(5), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1744), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1705), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1354), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1632), + [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(357), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), + [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), + [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1512), + [137] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(410), + [140] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1016), + [143] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(2), + [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [148] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1225), + [151] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1729), + [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1285), + [157] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(135), + [160] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1602), + [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1706), + [166] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1026), + [169] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1479), + [172] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1555), + [175] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(159), + [178] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(34), + [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(187), + [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(190), + [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1179), + [190] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1243), + [193] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1656), + [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(197), + [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(59), + [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), + [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1530), + [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), + [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1313), + [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1557), + [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1587), + [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1290), + [223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1626), + [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(475), + [229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(477), + [232] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(477), + [235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(226), + [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), + [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), + [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1521), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1672), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(230), + [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1633), + [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1033), + [262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), + [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), + [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), + [268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), + [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1245), + [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1194), + [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1670), + [276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(182), + [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), - [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1712), - [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1645), - [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1339), - [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1522), - [292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), - [294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [296] = {.entry = {.count = 1, .reusable = false}}, SHIFT(250), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1738), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1671), + [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1349), + [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1546), + [292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), + [294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [296] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), [298] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), - [300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(426), - [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1524), - [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1014), - [306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), - [308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(30), - [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1231), - [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), - [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1341), - [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1723), - [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1684), - [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1415), - [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1423), - [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1376), - [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1247), - [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1665), - [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(430), - [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), - [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), - [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), - [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), - [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), - [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), - [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), - [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), - [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), - [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), - [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1038), - [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), - [384] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [388] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(223), - [391] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_doc_comment, 1, 0, 0), - [393] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), - [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [397] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2, 0, 0), - [399] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2, 0, 0), - [401] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), - [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), - [405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), - [407] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1208), - [410] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(819), - [413] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), - [415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), - [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), - [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), - [421] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1658), - [424] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1209), - [427] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 12), - [429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), - [431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), - [433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), - [437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), - [441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), - [443] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 8, 0, 95), - [445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 8, 0, 95), - [447] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 121), - [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), - [451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 121), - [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), - [455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), - [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), - [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), - [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), - [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), - [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), - [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 137), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 137), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), - [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), - [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 103), - [491] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 103), SHIFT(1340), - [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 103), - [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), - [498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), - [500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), - [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), - [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), - [506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), - [508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), - [510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), - [512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), - [514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), - [516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), - [518] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1223), - [521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), - [523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), - [525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), - [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), - [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 11), - [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 11), - [533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 95), - [535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 95), - [537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 13), - [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 13), - [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), - [543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), - [545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), - [547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), - [549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 65), - [551] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 65), - [553] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [555] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1340), - [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), - [562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), - [564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), - [566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), - [568] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_expression, 4, 0, 21), - [570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_kernel_expression, 4, 0, 21), - [572] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), - [574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), - [576] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), - [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), - [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), - [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), - [590] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), - [593] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), - [596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), - [598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), - [600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), - [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), - [604] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [607] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [610] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), - [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), - [614] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), - [616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), - [618] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 35), - [620] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 35), SHIFT(1340), - [623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 35), - [625] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), - [627] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), - [629] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 41), - [631] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 41), - [633] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), - [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 4), - [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 30), - [639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 30), - [641] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 48), - [643] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 48), - [645] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 53), - [647] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 53), SHIFT(1340), - [650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 53), - [652] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 59), - [654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 59), - [656] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 61), - [658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 61), - [660] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), - [662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), - [664] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 65), - [666] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 65), - [668] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 78), - [670] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 78), SHIFT(1340), - [673] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 78), - [675] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 93), - [677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 93), - [679] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 7, 0, 94), - [681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 7, 0, 94), - [683] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), - [685] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), - [687] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1517), - [690] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1224), - [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), - [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1325), - [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [699] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), - [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [711] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), - [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1617), - [719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 123), - [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 143), - [723] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 124), - [725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 146), - [727] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1325), - [730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 150), - [732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 151), - [734] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 35), SHIFT(1325), - [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 153), - [739] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 156), - [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 18), - [743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 53), SHIFT(1325), - [746] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 78), SHIFT(1325), - [749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), - [751] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 103), SHIFT(1325), - [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 97), - [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 160), - [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 162), - [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 98), - [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 165), - [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 129), - [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), - [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 172), - [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 108), - [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 174), - [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 175), - [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 176), - [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 180), - [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 105), - [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), - [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 184), - [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 187), + [300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(403), + [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1548), + [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1026), + [306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), + [308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), + [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1187), + [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1419), + [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1271), + [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1453), + [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1455), + [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1456), + [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1457), + [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1466), + [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1325), + [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1471), + [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(409), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), + [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(509), + [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), + [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), + [364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(414), + [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), + [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), + [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), + [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_doc_comment, 1, 0, 0), + [392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), + [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [400] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2, 0, 0), + [405] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2, 0, 0), + [407] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), + [409] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), + [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), + [413] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1197), + [416] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(834), + [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), + [421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), + [423] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [425] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [427] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1719), + [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 42), + [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), + [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 42), + [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [440] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), + [454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), + [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), + [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 49), + [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 49), + [466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 12), + [468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), + [470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 54), + [472] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1351), + [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), + [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 60), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 60), + [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 62), + [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 62), + [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 13), + [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 13), + [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), + [495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), + [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [499] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1351), + [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 79), + [506] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1351), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_expression, 4, 0, 21), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_kernel_expression, 4, 0, 21), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [519] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1200), + [522] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 104), + [524] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1351), + [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), + [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 36), + [531] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1351), + [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), + [536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 7, 0, 95), + [538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 7, 0, 95), + [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), + [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), + [544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 122), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 122), + [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), + [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), + [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [556] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [559] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), + [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), + [566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), + [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), + [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), + [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), + [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), + [576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), + [578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), + [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), + [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), + [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), + [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), + [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), + [590] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 11), + [592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 11), + [594] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), + [596] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), + [598] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), + [600] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), + [602] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), + [604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), + [606] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), + [608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), + [610] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), + [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), + [614] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [617] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), + [622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), + [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), + [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), + [628] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), + [631] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), + [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), + [636] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), + [638] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), + [640] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), + [642] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 33), + [644] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 33), + [646] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), + [648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), + [650] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), + [652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), + [654] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), + [656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 4), + [658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 30), + [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 30), + [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 33), + [664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 33), + [666] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 66), + [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 66), + [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 94), + [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 94), + [674] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 66), + [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 66), + [678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 96), + [680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 96), + [682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 8, 0, 96), + [684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 8, 0, 96), + [686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 138), + [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 138), + [690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), + [692] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1233), + [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), + [697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), + [699] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), + [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), + [703] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1540), + [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), + [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [722] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), + [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), + [732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 99), + [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 106), + [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 109), + [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 18), + [740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 124), + [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 125), + [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 130), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 133), + [748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 134), + [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 81), + [752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 144), + [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 147), + [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 151), + [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 152), + [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 154), + [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 157), + [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 160), + [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 161), + [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 163), + [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 166), + [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 172), + [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 173), + [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 175), + [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 176), + [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 177), + [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 181), + [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 184), + [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 98), [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 188), - [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 49), - [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 52), - [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 132), - [796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 54), - [798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 191), - [800] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 80), - [802] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 81), - [804] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 133), - [806] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 44), - [808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 44), SHIFT(1340), - [811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 44), - [813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 44), - [815] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 44), SHIFT(1340), - [818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 44), - [820] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1515), - [823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1515), - [825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(725), - [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), - [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1514), - [831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1688), - [833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), - [835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), - [837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), - [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1690), - [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), - [843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), - [845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), - [847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(742), - [849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), - [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(744), - [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), - [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(749), - [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), - [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), - [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), - [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), - [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1599), - [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), - [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(737), - [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(738), - [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), - [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(730), - [877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), - [879] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1518), - [882] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1514), - [885] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1688), - [888] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1640), - [891] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1689), - [894] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1641), - [897] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1690), - [900] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1315), - [903] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(466), - [906] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1647), - [909] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(224), - [912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), - [914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1513), - [916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), - [918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(739), - [920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), - [922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), - [924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1445), - [926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1595), - [928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1498), - [930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), - [932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), - [934] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1245), - [937] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(186), - [940] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), - [942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(713), - [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1399), - [946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1459), - [948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), - [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(724), - [952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1499), - [954] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), - [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), - [959] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), - [961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), - [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(818), - [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), - [967] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), - [969] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1435), - [972] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1230), - [975] = {.entry = {.count = 1, .reusable = false}}, SHIFT(813), - [977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), - [979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), - [981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), - [983] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), - [985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(567), - [987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), - [989] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1083), - [991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), - [993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), - [995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), - [997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1485), - [999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [1001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [1003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1482), - [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), - [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [1009] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), - [1011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [1015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [1019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [1021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), - [1023] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1266), - [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), - [1028] = {.entry = {.count = 1, .reusable = false}}, SHIFT(810), - [1030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), - [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [1034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), - [1036] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(810), - [1039] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1260), - [1042] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), - [1044] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1261), - [1047] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1050] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(567), - [1053] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1264), - [1056] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1083), - [1059] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), - [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [1066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), - [1070] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 35), SHIFT(1266), - [1073] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(810), - [1076] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1260), - [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [1081] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1261), - [1084] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1087] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(567), - [1090] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1264), - [1093] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1083), - [1096] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), - [1101] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 53), SHIFT(1266), - [1104] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 78), SHIFT(1266), - [1107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), - [1109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), - [1111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), - [1113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), - [1115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 103), SHIFT(1266), - [1118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [1120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), - [1124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), - [1126] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), - [1128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), - [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), - [1132] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 17), - [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1219), - [1136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), - [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), - [1140] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 60), - [1142] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 40), - [1144] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 62), - [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), - [1150] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), - [1152] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 42), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), - [1156] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), - [1158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), - [1160] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), - [1162] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), - [1164] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), - [1166] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), - [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), - [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(728), - [1172] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), - [1174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), + [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 189), + [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 192), + [794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1235), + [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 82), + [799] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1356), + [802] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1356), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 50), + [807] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1356), + [810] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1356), + [813] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1356), + [816] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 53), + [818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 55), + [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 185), + [822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 45), + [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), SHIFT(1351), + [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), + [829] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 45), + [831] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), SHIFT(1351), + [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), + [836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1539), + [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), + [843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1189), + [846] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(188), + [849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), + [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), + [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1542), + [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1682), + [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1714), + [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), + [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1667), + [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), + [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), + [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), + [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), + [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), + [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), + [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1418), + [881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1494), + [885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), + [887] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), + [889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), + [891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), + [893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), + [895] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1542), + [898] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1682), + [901] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1714), + [904] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1666), + [907] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1715), + [910] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1667), + [913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1716), + [916] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1320), + [919] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(547), + [922] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1673), + [925] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), + [928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), + [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), + [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1484), + [937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1372), + [941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), + [943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(757), + [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(717), + [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(692), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(698), + [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), + [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), + [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(705), + [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), + [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(710), + [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(711), + [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), + [977] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1497), + [980] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), + [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), + [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [996] = {.entry = {.count = 1, .reusable = false}}, SHIFT(128), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [1008] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1568), + [1016] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), + [1018] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1263), + [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1023] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), + [1025] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1263), + [1028] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), + [1030] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1263), + [1033] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1263), + [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), + [1038] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1260), + [1041] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1263), + [1044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), + [1046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1048] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), + [1050] = {.entry = {.count = 1, .reusable = false}}, SHIFT(827), + [1052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [1054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(510), + [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), + [1058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1112), + [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), + [1064] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), + [1066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [1068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 17), + [1070] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 61), + [1072] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 63), + [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [1076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [1078] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 41), + [1080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), + [1082] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 43), + [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), + [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1558), + [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(754), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(492), + [1096] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), + [1099] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1270), + [1102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [1104] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1294), + [1107] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), + [1110] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(629), + [1113] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1267), + [1116] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), + [1119] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), + [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1124] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), + [1127] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1270), + [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), + [1132] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1294), + [1135] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), + [1138] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(629), + [1141] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1267), + [1144] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), + [1147] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1660), + [1152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), - [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), - [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1474), - [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), - [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), - [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), - [1190] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1470), - [1193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [1195] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), - [1197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), - [1199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [1201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), - [1203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), - [1205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), - [1207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [1209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), - [1213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(464), - [1215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), - [1217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), - [1219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [1221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [1223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), - [1225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), - [1227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), - [1229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), - [1231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [1233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), - [1235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), - [1237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(441), - [1239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [1241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353), - [1243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), - [1245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [1247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), - [1249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [1251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), - [1253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), - [1255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(435), - [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(437), - [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(436), - [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1470), - [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), - [1271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), - [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), - [1275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), - [1277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), - [1279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), - [1281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), - [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(715), - [1285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), - [1287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(745), - [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), - [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(726), - [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1608), - [1295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), - [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1532), - [1300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1533), - [1303] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1537), - [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1689), - [1309] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1641), - [1312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1277), - [1315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), - [1318] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(224), - [1321] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), - [1323] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1163), - [1326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), - [1328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), - [1330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), - [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), - [1334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 127), - [1336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1373), - [1338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 84), - [1340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 85), - [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 19), - [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 50), - [1346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), - [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), - [1350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 22), - [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), - [1354] = {.entry = {.count = 1, .reusable = false}}, SHIFT(518), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1215), - [1358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1344), - [1360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(803), - [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 128), - [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 92), - [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 38), - [1368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), - [1370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 101), - [1372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), - [1374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 39), - [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 57), - [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), - [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 110), - [1382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(854), - [1384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), - [1386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1661), - [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), - [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 148), - [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 73), - [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), - [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 74), - [1398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 38), - [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), - [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 92), - [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 74), - [1406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 39), - [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 38), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), - [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 148), - [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 128), - [1416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 110), - [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 173), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 100), - [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 75), - [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 102), - [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 76), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 104), - [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 106), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 99), - [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 109), - [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 85), - [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 122), - [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 125), - [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 126), - [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 102), - [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 130), - [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 131), - [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 134), - [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 46), - [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 142), - [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 144), - [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 145), - [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 147), - [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 127), - [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 149), - [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 152), - [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 157), - [1470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), - [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), - [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 161), - [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 163), - [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 164), - [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 170), - [1482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), - [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 177), - [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), - [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 181), - [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), - [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 189), - [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 37), - [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 67), - [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 68), - [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), - [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 45), - [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), - [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 47), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(508), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), + [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), + [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), + [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), + [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), + [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [1216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [1218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), + [1220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), + [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1606), + [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), + [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), + [1234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), + [1236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), + [1238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), + [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), + [1244] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), + [1246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), + [1248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(520), + [1250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), + [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), + [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), + [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), + [1258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), + [1260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), + [1262] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), + [1264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), + [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), + [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), + [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), + [1276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1483), + [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), + [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(759), + [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), + [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), + [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), + [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [1292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), + [1294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1734), + [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), + [1300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1743), + [1303] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1715), + [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1667), + [1309] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1326), + [1312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), + [1315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), + [1318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [1320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1731), + [1322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), + [1324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1415), + [1326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [1328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), + [1330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), + [1334] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1127), + [1337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), + [1339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), + [1341] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), + [1343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 85), + [1345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 128), + [1347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1393), + [1349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 51), + [1351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 86), + [1353] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1534), + [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 19), + [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), + [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 75), + [1368] = {.entry = {.count = 1, .reusable = false}}, SHIFT(845), + [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [1372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1687), + [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), + [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), + [1378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), + [1380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), + [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [1384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1710), + [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 39), + [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), + [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 40), + [1394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 22), + [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 39), + [1398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 58), + [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), + [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 40), + [1406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 74), + [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 39), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 93), + [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 102), + [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(893), + [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 75), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 111), + [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 93), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 129), + [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 111), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 149), + [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 129), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 149), + [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 38), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), + [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 46), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 67), + [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 48), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 73), + [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 47), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 51), + [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 76), + [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 52), + [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 77), + [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 34), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 80), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 83), + [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 84), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 67), + [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 100), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 101), + [1470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), + [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 76), + [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 103), + [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 77), + [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 105), + [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 107), + [1482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 108), + [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 110), + [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 86), + [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 46), + [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), + [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 123), + [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 126), + [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 127), + [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 48), + [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 103), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 131), + [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 132), + [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 135), [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), - [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 96), - [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 51), - [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 33), - [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), - [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), - [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), - [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 55), - [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 56), - [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 45), - [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 66), - [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 47), - [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 72), - [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 50), - [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 75), - [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 51), - [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 76), - [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 33), - [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 79), - [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 82), - [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 83), - [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 66), - [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 107), - [1556] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1363), - [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), - [1560] = {.entry = {.count = 1, .reusable = false}}, SHIFT(967), - [1562] = {.entry = {.count = 1, .reusable = false}}, SHIFT(947), - [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), - [1566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), - [1568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), - [1570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1697), - [1572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), - [1574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), - [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), - [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(650), - [1580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), - [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1584), - [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), - [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), - [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1632), - [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), - [1592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), - [1594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), - [1596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), - [1598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), - [1600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), - [1602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), - [1604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), - [1606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(653), - [1608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 92), - [1610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), - [1612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), - [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1590), - [1616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), - [1618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), - [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), - [1622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), - [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), - [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), - [1628] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 119), - [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), - [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), - [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), - [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), - [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1560), - [1640] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1363), - [1643] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), - [1645] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(967), - [1648] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(947), - [1651] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(224), - [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), - [1656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 167), - [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(914), - [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1374), - [1662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 71), - [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), - [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), - [1668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 178), - [1670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 139), - [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), - [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), - [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), - [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1542), - [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1695), - [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), - [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), - [1686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1319), - [1688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), - [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1657), - [1692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 155), - [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 186), - [1696] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), - [1698] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1716), - [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), - [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1360), - [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1384), - [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), - [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1493), - [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), - [1712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), - [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), - [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), - [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), - [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), - [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), - [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1249), - [1726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), - [1728] = {.entry = {.count = 1, .reusable = false}}, SHIFT(809), - [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), - [1732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 141), - [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), - [1736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), - [1738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 92), - [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), - [1742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), - [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1382), - [1746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(428), - [1748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 70), - [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 168), - [1752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 154), - [1754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), - [1756] = {.entry = {.count = 1, .reusable = false}}, SHIFT(955), - [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1512), - [1760] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1512), - [1763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 91), - [1765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 169), - [1767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), - [1769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), - [1771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), - [1773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), - [1775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), - [1777] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 140), - [1779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), - [1781] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), - [1783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 85), - [1785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), - [1787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 69), - [1789] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 185), - [1791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), - [1793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 118), - [1795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 120), - [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 166), - [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 190), - [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 179), - [1803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), - [1805] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 136), - [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 136), - [1809] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 116), - [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 116), - [1813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 90), - [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 90), - [1817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 86), - [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 86), - [1821] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1422), - [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [1825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1552), - [1827] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 87), - [1829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 87), - [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), - [1833] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 91), - [1835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 91), - [1837] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 88), - [1839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 88), - [1841] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1346), - [1843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), - [1845] = {.entry = {.count = 1, .reusable = false}}, SHIFT(948), - [1847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 58), - [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 58), - [1851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 111), - [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 111), - [1855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 112), - [1857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 112), - [1859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 89), - [1861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 89), - [1863] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 113), - [1865] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 113), - [1867] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 114), - [1869] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 114), - [1871] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 115), - [1873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 115), - [1875] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1698), - [1877] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1692), - [1879] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1438), - [1881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), - [1883] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1436), - [1885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1442), - [1887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), - [1889] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1441), - [1891] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 135), - [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 135), - [1895] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1899] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1449), - [1901] = {.entry = {.count = 1, .reusable = false}}, SHIFT(927), - [1903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [1905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [1907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), - [1909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), - [1911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [1913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), - [1915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [1917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [1919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), - [1921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [1923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), - [1925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [1927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), - [1929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [1931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), - [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), - [1937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [1939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), - [1941] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1355), - [1943] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), - [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 143), + [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 145), + [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 146), + [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 148), + [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 128), + [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 52), + [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 34), + [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 150), + [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 153), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), + [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), + [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 162), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), + [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 164), + [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 165), + [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), + [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 174), + [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 178), + [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), + [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), + [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 68), + [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 69), + [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 190), + [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 97), + [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), + [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), + [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), + [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 56), + [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 57), + [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), + [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), + [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1469), + [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(971), + [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), + [1582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1490), + [1585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1580), + [1587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), + [1589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1401), + [1591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), + [1593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), + [1595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), + [1597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1614), + [1599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), + [1601] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1469), + [1604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), + [1606] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(971), + [1609] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(949), + [1612] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), + [1615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), + [1619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [1621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1650), + [1623] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1541), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1593), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [1634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), + [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), + [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1740), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 168), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), + [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(680), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), + [1676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 93), + [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), + [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 120), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 156), + [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), + [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), + [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), + [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 72), + [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), + [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), + [1700] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 187), + [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 140), + [1704] = {.entry = {.count = 1, .reusable = false}}, SHIFT(657), + [1706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1385), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1379), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1514), + [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1566), + [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), + [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), + [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1681), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1722), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(604), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), + [1742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 179), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1490), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), + [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), + [1752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(836), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [1756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), + [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), + [1762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 142), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [1768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 93), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), + [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 70), + [1774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 191), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), + [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), + [1786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(980), + [1788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(439), + [1790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 92), + [1792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), + [1794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1537), + [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 119), + [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), + [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 121), + [1803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 180), + [1805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), + [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 186), + [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), + [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 141), + [1813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 155), + [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 86), + [1817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 71), + [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), + [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), + [1823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 167), + [1825] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 169), + [1827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 170), + [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), + [1831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 87), + [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 87), + [1835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 136), + [1837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 136), + [1839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 137), + [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 137), + [1843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 112), + [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 112), + [1851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 113), + [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 113), + [1855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 114), + [1857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 114), + [1859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 115), + [1861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 115), + [1863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [1865] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 116), + [1867] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 116), + [1869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1631), + [1871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), + [1873] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1630), + [1875] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 117), + [1877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 117), + [1879] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1638), + [1881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(956), + [1883] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 89), + [1885] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 89), + [1887] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1613), + [1889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [1891] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1609), + [1893] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 90), + [1895] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 90), + [1897] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1621), + [1899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), + [1901] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1620), + [1903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1473), + [1905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [1907] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1472), + [1909] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1627), + [1911] = {.entry = {.count = 1, .reusable = false}}, SHIFT(960), + [1913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 91), + [1915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 91), + [1917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 88), + [1919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 88), + [1921] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 59), + [1923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 59), + [1925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [1931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), + [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), + [1937] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1939] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1941] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1645), + [1943] = {.entry = {.count = 1, .reusable = false}}, SHIFT(958), + [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), [1947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), - [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), - [1953] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [1959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), - [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), - [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), - [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), - [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [1975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), - [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), - [1981] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1275), - [1983] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1519), - [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), - [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), - [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1395), - [1999] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), - [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [2003] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), - [2005] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1069), - [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(958), - [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(968), - [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), - [2013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1648), - [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1329), - [2021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(960), - [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), - [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), - [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(957), - [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(966), - [2035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), - [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), - [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(953), - [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1354), - [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1553), - [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1660), - [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), - [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), - [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), - [2067] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1099), - [2069] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [2071] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1403), - [2074] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), - [2076] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1403), - [2079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), - [2081] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), - [2083] = {.entry = {.count = 1, .reusable = false}}, SHIFT(64), - [2085] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1121), - [2088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), - [2090] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), - [2092] = {.entry = {.count = 1, .reusable = false}}, SHIFT(172), - [2094] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), - [2096] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), - [2098] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), - [2100] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1403), - [2103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), - [2105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), - [2107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), - [2109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), - [2111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), - [2113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), - [2115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 117), - [2117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), - [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 138), - [2121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1691), - [2123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), - [2125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), - [2127] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1164), - [2130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), - [2132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(54), - [2134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), - [2136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), - [2138] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(893), - [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), - [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), - [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), - [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), - [2149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1284), - [2151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), - [2153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), - [2155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 63), - [2157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), - [2159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), - [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), - [2163] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), - [2165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), - [2167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), - [2169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(772), - [2171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), - [2173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(196), - [2175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 43), - [2177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), - [2179] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(194), - [2182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1179), - [2184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [2186] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1691), - [2189] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), - [2191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), - [2193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), - [2195] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), - [2197] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1099), - [2200] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), - [2202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), - [2204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), - [2206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(893), - [2208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), - [2210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), - [2212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), - [2214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), - [2216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), - [2218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 63), - [2220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), - [2222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [2224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [2226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [2228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1634), - [2230] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(619), - [2233] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), - [2235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), - [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), - [2239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [2241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), - [2243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), - [2245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), - [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), - [2249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), - [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [2253] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), - [2255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1114), - [2261] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), - [2263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), - [2265] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), - [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [2269] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), - [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), - [2273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1548), - [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [2277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), - [2279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), - [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [2283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403), - [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), - [2287] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1395), - [2290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), - [2292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), - [2294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1127), - [2297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), - [2299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [2301] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1114), - [2304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), - [2306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), - [2308] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1336), - [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), - [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), - [2315] = {.entry = {.count = 1, .reusable = false}}, SHIFT(937), - [2317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1293), - [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), - [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), - [2323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), - [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), - [2327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), - [2329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), - [2331] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(40), - [2334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [2336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), - [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), - [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [2342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), - [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [2348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), - [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [2354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), - [2358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), - [2360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [2362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), - [2364] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1705), - [2367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [2369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [2371] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), - [2373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [2375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [2377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), - [2379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1062), - [2382] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), - [2384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [2386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), - [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [2390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), - [2392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [2394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [2396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [2398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), - [2400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [2402] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1705), - [2405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), - [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [2409] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), - [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [2413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), - [2415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), - [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(452), - [2419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [2421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), - [2423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [2437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), - [2443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [2445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(546), - [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), - [2449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [2451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [2453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [2455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), - [2457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), - [2459] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1705), - [2462] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 64), SHIFT_REPEAT(1308), - [2465] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 64), - [2467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), - [2469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), - [2471] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 64), SHIFT_REPEAT(625), - [2474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 64), - [2476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), - [2478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), - [2480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(420), - [2482] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1305), - [2485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), - [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), - [2489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), - [2491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [2493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), - [2495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), - [2497] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), - [2499] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1248), - [2502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [2504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), - [2506] = {.entry = {.count = 1, .reusable = false}}, SHIFT(929), - [2508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1317), - [2510] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1282), - [2513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), - [2515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), - [2517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [2519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(938), - [2521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1327), - [2523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), - [2525] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1290), - [2528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), - [2530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), - [2532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), - [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), - [2536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 43), - [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), - [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(759), - [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), - [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), - [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [2550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), - [2552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 43), - [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1172), - [2556] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1332), - [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1016), - [2560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), - [2562] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1098), - [2564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), - [2566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [2568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), - [2570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), - [2572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1001), - [2574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), - [2576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), - [2578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [2580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), - [2582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), - [2584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(754), - [2586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), - [2588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), - [2590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), - [2592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(762), - [2594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), - [2596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(984), - [2598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), - [2600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), - [2602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), - [2604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(838), - [2606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1286), - [2608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), - [2610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), - [2612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), - [2614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), - [2616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(758), - [2618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), - [2620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), - [2622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), - [2624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), - [2626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), - [2628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1024), - [2630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), - [2632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [2634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(782), - [2636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), - [2638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 77), - [2640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), - [2642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), - [2644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), - [2646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), - [2648] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1253), - [2650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), - [2652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [2654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), - [2656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1005), - [2658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), - [2660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [2662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), - [2664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(998), - [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), - [2668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), - [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1000), - [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), - [2676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), - [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), - [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), - [2682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [2684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), - [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), - [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), - [2690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), - [2692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [2694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), - [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [2700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [2702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), - [2704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), - [2706] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 36), - [2708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), - [2710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), - [2712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), - [2714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [2716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(812), - [2718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), - [2720] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), - [2722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [2724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), - [2726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [2728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), - [2730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), - [2732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [2734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [2736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), - [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [2740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), - [2742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1054), - [2744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1381), - [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [2752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), - [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), - [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(736), - [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), - [2760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), - [2762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1380), - [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [2766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), - [2768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), - [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), - [2772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), - [2774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), - [2776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1296), - [2778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), - [2780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [2782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [2784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), - [2786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), - [2788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [2790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), - [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), - [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(642), - [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), - [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), - [2800] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), - [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [2804] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), - [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), - [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1237), - [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), - [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), - [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), - [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1345), - [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), - [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), - [2822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), - [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), - [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), - [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [2830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), - [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), - [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(783), - [2838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), - [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), - [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), - [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), - [2846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), - [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), - [2850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), - [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), - [2856] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), - [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(962), - [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), - [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), - [2866] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), - [2868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), - [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), - [2874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), - [2878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), - [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), - [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), - [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), - [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), - [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), - [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1254), - [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), - [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), - [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), - [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), - [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), - [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1707), - [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), - [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), - [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(833), - [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), - [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), - [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), - [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(532), - [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(533), - [2930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), - [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), - [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), - [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), - [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), - [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), - [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), - [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1314), - [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), - [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), - [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(788), - [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [2960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), - [2962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1680), - [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), - [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), - [2968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), - [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), - [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1528), - [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), - [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1393), - [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), - [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(781), - [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), - [2984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), - [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), - [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), - [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), - [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), - [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), - [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), - [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), - [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1490), - [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1531), - [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), - [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), - [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), - [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), - [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(796), - [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), - [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1492), - [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), - [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), - [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395), - [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1258), - [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(954), - [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), - [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), - [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), - [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), - [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), - [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), - [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), - [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1364), - [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), - [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), - [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(765), - [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), - [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(964), - [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), - [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(775), - [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), - [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), - [3076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), - [3078] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), - [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), - [3082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), - [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), - [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1417), - [3090] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), - [3094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), - [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(971), - [3100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), - [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1265), - [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), - [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), - [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), - [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1558), - [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1102), - [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1507), - [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), - [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), - [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), - [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(536), - [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), - [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), - [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), - [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1546), - [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), - [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), - [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [3156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1285), - [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1627), - [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1557), - [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), - [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), - [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), - [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), - [3174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), - [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1580), - [3178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), - [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), - [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1579), - [3186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), - [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1591), - [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1593), - [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), - [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1598), - [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), - [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), - [3200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), - [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), - [3206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1629), - [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), - [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), - [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), - [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1650), - [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1651), - [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1318), - [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), - [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), - [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), - [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1664), - [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1322), - [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), - [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1668), - [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), - [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1671), - [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), - [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1674), - [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), - [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), - [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(467), - [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), - [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), - [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), - [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), - [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), - [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(804), - [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), - [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [3272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 33), - [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [3276] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 34), - [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), - [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [1953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), + [1955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [1957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), + [1959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), + [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), + [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), + [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(914), + [1975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), + [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [1981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), + [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), + [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), + [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [2003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [2005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), + [2007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2009] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1078), + [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), + [2013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1310), + [2015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1576), + [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), + [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [2021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), + [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), + [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), + [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [2035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1237), + [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), + [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), + [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), + [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), + [2069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), + [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), + [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), + [2077] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), + [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), + [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), + [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [2089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2091] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(902), + [2094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), + [2096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), + [2098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), + [2100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), + [2102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), + [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [2106] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1257), + [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [2111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(196), + [2114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1615), + [2116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), + [2118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1059), + [2120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [2122] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [2124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [2126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), + [2128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), + [2130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [2132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [2134] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1528), + [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), + [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 118), + [2141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), + [2143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), + [2145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), + [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), + [2149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1506), + [2151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), + [2153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [2155] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1528), + [2158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [2160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), + [2162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), + [2164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), + [2166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), + [2168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [2170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [2172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 64), + [2174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 64), + [2176] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1192), + [2179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [2181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1059), + [2184] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), + [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), + [2188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), + [2190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), + [2192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1615), + [2195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), + [2197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 44), + [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(765), + [2201] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1528), + [2204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), + [2206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [2210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), + [2212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 139), + [2214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), + [2216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [2218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), + [2220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [2222] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [2224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [2226] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), + [2228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [2230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [2232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), + [2234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), + [2236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), + [2240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), + [2242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), + [2244] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), + [2246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), + [2248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [2250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1357), + [2252] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), + [2254] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1452), + [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [2261] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1121), + [2264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), + [2266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), + [2268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1492), + [2270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), + [2272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), + [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [2276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [2278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [2280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [2282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), + [2284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), + [2286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [2288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [2290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [2292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [2294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), + [2296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1595), + [2298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [2300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 65), SHIFT_REPEAT(1281), + [2303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 65), + [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), + [2311] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1291), + [2314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [2316] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 65), SHIFT_REPEAT(631), + [2319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 65), + [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [2323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), + [2325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), + [2327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [2329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [2331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), + [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [2335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [2339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1116), + [2341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [2343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), + [2345] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(38), + [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), + [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), + [2354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), + [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1347), + [2358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [2362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [2364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), + [2368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), + [2370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [2372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [2374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [2376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), + [2378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), + [2380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [2384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [2386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), + [2390] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1452), + [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [2401] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1140), + [2404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), + [2406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), + [2408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [2410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [2412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), + [2414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), + [2416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), + [2418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [2420] = {.entry = {.count = 1, .reusable = false}}, SHIFT(965), + [2422] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1265), + [2424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [2426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), + [2428] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1338), + [2431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), + [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), + [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [2437] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), + [2439] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1452), + [2442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), + [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1369), + [2450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [2452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [2454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [2458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), + [2460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1055), + [2462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), + [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [2466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1055), + [2469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), + [2471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), + [2473] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1347), + [2476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1583), + [2478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), + [2480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [2482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [2484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), + [2486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), + [2488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [2490] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1357), + [2493] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), + [2495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), + [2497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [2501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), + [2503] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1304), + [2506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), + [2508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [2510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), + [2512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1637), + [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [2516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), + [2518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [2520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [2522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), + [2524] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1489), + [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [2529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), + [2531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), + [2533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(947), + [2535] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1322), + [2537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [2539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(959), + [2541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1333), + [2543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(630), + [2546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), + [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), + [2552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), + [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), + [2556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), + [2560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), + [2562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1247), + [2564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), + [2566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), + [2568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [2570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), + [2572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1095), + [2574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), + [2576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), + [2578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), + [2580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1283), + [2582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1000), + [2584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), + [2586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(783), + [2588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [2590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 44), + [2592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [2594] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1289), + [2596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [2598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), + [2600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), + [2602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [2604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [2606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), + [2608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), + [2610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 44), + [2612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2614] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1335), + [2616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [2618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), + [2620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), + [2622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(800), + [2624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1001), + [2626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), + [2628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), + [2632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [2634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), + [2636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), + [2638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), + [2640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(798), + [2642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), + [2644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), + [2646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [2648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), + [2650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [2652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), + [2654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [2656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), + [2658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), + [2660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(781), + [2662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [2664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 78), + [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1417), + [2668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), + [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [2676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(951), + [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), + [2682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), + [2684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), + [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), + [2690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), + [2692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), + [2694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1013), + [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), + [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [2700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), + [2702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), + [2704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [2706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(778), + [2710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), + [2712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 37), + [2714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), + [2716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [2718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [2720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), + [2722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), + [2724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [2726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), + [2728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [2730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [2732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), + [2734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1695), + [2736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), + [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [2740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [2742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), + [2744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(789), + [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [2752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), + [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), + [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [2760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), + [2762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), + [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [2766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [2768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), + [2772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), + [2774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [2776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), + [2778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), + [2782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(690), + [2784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [2786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), + [2788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), + [2790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), + [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), + [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), + [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(847), + [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1711), + [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), + [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), + [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), + [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [2822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), + [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(984), + [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), + [2830] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(806), + [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [2838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1296), + [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), + [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), + [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), + [2846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), + [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), + [2850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), + [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(809), + [2856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), + [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), + [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), + [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [2866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), + [2868] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_arguments, 3, 0, 0), + [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), + [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [2874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 34), + [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [2878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 35), + [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1373), + [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), + [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(983), + [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), + [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), + [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1394), + [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), + [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), + [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), + [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), + [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), + [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(638), + [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), + [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), + [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), + [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(515), + [2930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), + [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), + [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), + [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), + [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), + [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), + [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(838), + [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), + [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [2950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), + [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), + [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), + [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1591), + [2960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), + [2962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), + [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), + [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [2968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), + [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), + [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), + [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), + [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [2984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), + [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(382), + [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), + [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), + [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1474), + [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), + [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), + [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), + [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), + [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), + [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), + [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), + [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), + [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), + [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1319), + [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), + [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1341), + [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), + [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), + [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), + [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), + [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1220), + [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), + [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(641), + [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), + [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), + [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1395), + [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), + [3076] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), + [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(427), + [3082] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), + [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(762), + [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), + [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), + [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), + [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), + [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), + [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), + [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), + [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), + [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), + [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), + [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), + [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), + [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), + [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(792), + [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), + [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), + [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), + [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1594), + [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(794), + [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), + [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), + [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), + [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), + [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), + [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), + [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1496), + [3156] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), + [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), + [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1286), + [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1115), + [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [3174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1481), + [3178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), + [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(613), + [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [3186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1371), + [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), + [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), + [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), + [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), + [3200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), + [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [3206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), + [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1559), + [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1571), + [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), + [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), + [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), + [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1314), + [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), + [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1589), + [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), + [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1597), + [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), + [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1607), + [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), + [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), + [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), + [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), + [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), + [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), + [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), + [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), + [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), + [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), + [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), + [3276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), + [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), + [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), + [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1690), + [3292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), + [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [3298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), + [3300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [3302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1697), + [3304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), + [3306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), + [3308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [3310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1712), + [3312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [3314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), + [3318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), + [3320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [3324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [3326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), }; enum ts_external_scanner_symbol_identifiers { From e0357061c5be881397a0f2ee9f08cca1125a8c3c Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:10:50 +1000 Subject: [PATCH 03/10] fixes --- crates/osprey-codegen/src/builder.rs | 1 + crates/osprey-codegen/src/curry.rs | 1 + crates/osprey-codegen/src/expr.rs | 4 + crates/osprey-syntax/src/default/expr.rs | 21 +- crates/osprey-types/src/check.rs | 5 +- crates/osprey-types/src/ctx.rs | 15 + crates/osprey-types/src/expr.rs | 5 + .../src/generics_variance_assign_tests.rs | 374 ++++++++---------- .../src/generics_variance_builtin_tests.rs | 229 ++++------- crates/osprey-types/src/unify.rs | 9 + docs/specs/0004-TypeSystem.md | 29 +- .../projects/modules/src/domain/json.ospml | 9 - 12 files changed, 320 insertions(+), 382 deletions(-) diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs index b7b9b285..c4581585 100644 --- a/crates/osprey-codegen/src/builder.rs +++ b/crates/osprey-codegen/src/builder.rs @@ -702,6 +702,7 @@ impl Codegen { /// [TYPE-FN-HIGHER-ORDER]. pub(crate) fn callee_fn_type(&self, expr: &Expr) -> Option { match expr { + Expr::TypeApply { function, .. } => self.callee_fn_type(function), Expr::Identifier(name) => self.identifier_fn_type(name), // A call evaluates to its callee's return type — recurse so a chain // peels one arrow per application. diff --git a/crates/osprey-codegen/src/curry.rs b/crates/osprey-codegen/src/curry.rs index 7656b973..94a13b1c 100644 --- a/crates/osprey-codegen/src/curry.rs +++ b/crates/osprey-codegen/src/curry.rs @@ -46,6 +46,7 @@ fn spine(expr: &Expr) -> Option<(&str, Vec>)> { let mut node = expr; loop { match node { + Expr::TypeApply { function, .. } => node = function, Expr::Call { function, arguments, diff --git a/crates/osprey-codegen/src/expr.rs b/crates/osprey-codegen/src/expr.rs index dfbffcca..8a17dad6 100644 --- a/crates/osprey-codegen/src/expr.rs +++ b/crates/osprey-codegen/src/expr.rs @@ -48,6 +48,7 @@ pub(crate) fn gen_expr(cg: &mut Codegen, expr: &Expr) -> Result { None => Err(CodegenError::unknown(name)), }, }, + Expr::TypeApply { function, .. } => gen_expr(cg, function), Expr::Binary { op, left, right } => gen_binary(cg, op, left, right), Expr::Unary { op, operand } => gen_unary(cg, op, operand), Expr::Call { @@ -806,6 +807,9 @@ fn gen_call( arguments: &[Expr], named: &[NamedArgument], ) -> Result { + if let Expr::TypeApply { function, .. } = function { + return gen_call(cg, function, arguments, named); + } // A directly-applied lambda (`x |> fn(y) => …`, `(fn(y) => …)(x)`) is // beta-reduced inline. if let Expr::Lambda { diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index 4e0ca55d..cc6e969d 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -200,13 +200,6 @@ impl Lowerer<'_> { fn lower_call(&self, node: Node<'_>) -> Expr { let mut callee = self.lower_expr_field(node, "callee"); - if let Some(args) = node.child_by_field_name("type_arguments") { - callee = Expr::TypeApply { - function: Box::new(callee), - type_args: self.named_of_kind(args, "type_list").into_iter() - .flat_map(|list| self.lower_type_list(list)).collect(), - }; - } if let Some(member) = node.child_by_field_name("member") { return Expr::FieldAccess { target: Box::new(callee), @@ -224,6 +217,17 @@ impl Lowerer<'_> { // field-access callee lowers to an ordinary call with the receiver as the // first positional argument — keeping method calls invisible downstream. let (mut arguments, named_arguments) = self.lower_arg_list(node); + if let Some(args) = node.child_by_field_name("type_arguments") { + if let Expr::FieldAccess { target, field } = callee { + arguments.insert(0, *target); + callee = Expr::Identifier(field); + } + callee = Expr::TypeApply { + function: Box::new(callee), + type_args: self.named_of_kind(args, "type_list").into_iter() + .flat_map(|list| self.lower_type_list(list)).collect(), + }; + } match callee { Expr::FieldAccess { target, field } => { arguments.insert(0, *target); @@ -461,6 +465,9 @@ fn fragment_prefix() -> u32 { fn parse_fragment(frag: &str) -> Expr { let parsed = crate::parse_program(&format!("{FRAGMENT_BINDING}{frag}\n")); + if !parsed.errors.is_empty() { + return Expr::Identifier(frag.trim().to_owned()); + } match parsed.program.statements.into_iter().next() { Some(Stmt::Let { value, .. }) => value, _ => Expr::Identifier(frag.trim().to_string()), diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 2572fb52..9602c78b 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -418,11 +418,14 @@ impl Checker { } let param_names: Vec = type_params.iter().map(|p| p.name.clone()).collect(); for v in variants { - let fields = v + let fields: Vec<(String, String)> = v .fields .iter() .map(|f| (f.name.clone(), f.ty.clone())) .collect(); + if is_record { + self.ctx.set_record(name.to_owned(), param_names.clone(), fields.clone()); + } let _ = self.ctors.insert( v.name.clone(), CtorInfo { diff --git a/crates/osprey-types/src/ctx.rs b/crates/osprey-types/src/ctx.rs index cc34292f..cfd54421 100644 --- a/crates/osprey-types/src/ctx.rs +++ b/crates/osprey-types/src/ctx.rs @@ -15,6 +15,8 @@ pub struct InferCtx { /// assignability so `Source` matches covariantly. Implements /// [TYPE-VARIANCE-ASSIGN]. variances: HashMap>, + /// Nominal record layouts, before instantiating their declaration binders. + records: HashMap, Vec<(String, String)>)>, } impl InferCtx { @@ -34,6 +36,19 @@ impl InferCtx { self.variances.get(name).map(Vec::as_slice) } + /// Register a record's generic field template [TYPE-GENERICS-DECL]. + pub(crate) fn set_record(&mut self, name: String, params: Vec, fields: Vec<(String, String)>) { + let _ = self.records.insert(name, (params, fields)); + } + + /// Resolve a nominal record application to its instantiated fields. + pub(crate) fn record_fields(&self, name: &str, args: &[Type]) -> Option> { + let (params, fields) = self.records.get(name)?; + if params.len() != args.len() { return None; } + let binder = params.iter().cloned().zip(args.iter().cloned()).collect(); + Some(fields.iter().map(|(field, ty)| (field.clone(), crate::convert::type_name_to_type(ty, &binder))).collect()) + } + /// Allocate a fresh, unbound type variable. pub fn fresh(&mut self) -> Type { let id = VarId::try_from(self.subst.len()).unwrap_or(VarId::MAX); diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index 63a26634..b46f7b7b 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -195,6 +195,11 @@ impl Checker { self.record_field_access_on_fieldless(field, name); } } + if let Type::Con { name, args } = other { + if let Some(ty) = self.ctx.record_fields(name, args).and_then(|fields| fields.get(field).cloned()) { + return ty; + } + } self.ctx.fresh() } } diff --git a/crates/osprey-types/src/generics_variance_assign_tests.rs b/crates/osprey-types/src/generics_variance_assign_tests.rs index 4aaa029d..9990ac8a 100644 --- a/crates/osprey-types/src/generics_variance_assign_tests.rs +++ b/crates/osprey-types/src/generics_variance_assign_tests.rs @@ -1,25 +1,23 @@ -//! Spec-driven assertions for the **directional** half of -//! [TYPE-VARIANCE-ASSIGN] (docs/specs/0004-TypeSystem.md). +//! Spec-driven assertions for assignment sites under declared variance +//! ([TYPE-VARIANCE-ASSIGN], [TYPE-VARIANCE-COERCION], +//! docs/specs/0004-TypeSystem.md). //! -//! "At *assignment sites* (call arguments, annotated bindings, return -//! positions), a variance-declared constructor's arguments are matched -//! directionally: covariant (`out`) arguments recurse expected-accepts-actual, -//! contravariant (`in`) arguments recurse with the roles flipped, invariant -//! arguments unify exactly." +//! `generics_variance_tests.rs` states where a marker may be WRITTEN. This +//! module states what writing it does to ASSIGNMENT — and the answer the spec +//! now gives explicitly is: nothing, today. The language's only coercion +//! (`T -> Result`, an implicit `Success`) changes the value's +//! representation, and nothing rebuilds a container's contents, so it is barred +//! from argument positions. With no other subtyping in the language, `out T`, +//! `in T` and an unannotated parameter accept and refuse exactly the same +//! programs. //! -//! `generics_variance_tests.rs` states where a marker may be WRITTEN; this -//! module states what writing it BUYS. The distinction matters because the two +//! That is a claim worth pinning precisely because it is invisible: the two //! shipped fixtures (`variance_covariant_result_payload.ospo` and -//! `variance_invariant_arg_mismatch.ospo`) assert the same rejection under -//! `out T` and under an unannotated parameter — so nothing in the tree today -//! separates a covariant container from an invariant one, and a checker that -//! ignored every marker at assignment sites would pass both. -//! -//! The relation being recursed is the one-way promotion `T -> Result` -//! that the direct value site already models (`the_direct_site_promotion_is_the -//! _relation_being_recursed` below is its control). Every claim here is made at -//! ALL THREE sites the spec names, because a relation implemented at one site -//! is not the relation the spec describes. +//! `variance_invariant_arg_mismatch.ospo`) assert the one direction all three +//! markers already agree on, so nothing in the tree separated them, and nothing +//! would have noticed a checker that quietly started coercing through argument +//! positions and silently misread a payload. Every claim is made at ALL THREE +//! sites the spec names, because a rule enforced at one site is not the rule. use crate::testutil::{accepts, rejects}; use osprey_syntax::Flavor; @@ -48,6 +46,11 @@ pub(crate) fn blocked(decls: &str, expected: &str, actual: &str) { } } +/// True when the checker accepts the program outright. +pub(crate) fn accepted(src: &str) -> bool { + crate::testutil::typecheck(Flavor::Default, src).is_empty() +} + /// A covariant container, plus producers at both instantiations. const FEED: &str = "type Feed = Feed { supply: T } | Dry\n\ fn feedInt() -> Feed = Feed { supply: 1 }\n\ @@ -60,12 +63,13 @@ const GATE: &str = "type Gate = Gate { admit: (T) -> bool } | Open\n\ fn gateRes() -> Gate> = Gate { admit: |x| => true }\n\ fn gateText() -> Gate = Gate { admit: |x| => true }\n"; -/// An invariant container. +/// An invariant container — the control the other two are measured against. const CELL: &str = "type Cell = Cell { slot: T }\n\ fn cellInt() -> Cell = Cell { slot: 1 }\n\ - fn cellRes() -> Cell> = Cell { slot: 20 * 5 }\n"; + fn cellRes() -> Cell> = Cell { slot: 20 * 5 }\n\ + fn cellText() -> Cell = Cell { slot: \"s\" }\n"; -/// The three containers nested one level inside each other. +/// The containers nested one level inside each other. const NESTED: &str = "type Feed = Feed { supply: T } | Dry\n\ type Gate = Gate { admit: (T) -> bool } | Open\n\ type Cell = Cell { slot: T }\n\ @@ -77,8 +81,7 @@ const NESTED: &str = "type Feed = Feed { supply: T } | Dry\n\ fn gateFeedRes() -> Gate>> = Gate { admit: |x| => true }\n\ fn gateGateInt() -> Gate> = Gate { admit: |x| => true }\n"; -/// A covariant container over FUNCTION payloads, where the structural rule -/// (contravariant parameters, covariant returns) is the thing recursed into. +/// A covariant container over FUNCTION payloads. const FNPAYLOAD: &str = "type Feed = Feed { supply: T } | Dry\n\ fn feedTakesInt() -> Feed<(int) -> bool> = Feed { supply: |x| => true }\n\ fn feedTakesRes() -> Feed<(Result) -> bool> = \ @@ -87,186 +90,205 @@ const FNPAYLOAD: &str = "type Feed = Feed { supply: T } | Dry\n\ fn feedGivesRes() -> Feed<(int) -> Result> = Feed { supply: |x| => x * 2 }\n"; // --------------------------------------------------------------------------- -// The control: the relation exists at depth 0 +// [TYPE-VARIANCE-COERCION] — the coercion exists, at depth 0 only // --------------------------------------------------------------------------- -/// The one-way promotion `T -> Result` holds at a direct value site. Every -/// rejection below that should have been an acceptance is therefore a failure to -/// RECURSE the relation, not a missing relation. +/// "A bare `T` satisfies a `Result` slot (an implicit `Success`)." #[test] -fn the_direct_site_promotion_is_the_relation_being_recursed() { +fn the_coercion_holds_at_a_direct_value_site() { flows("", "Result", "5"); } -/// Its inverse never holds, at depth 0 or anywhere else. +/// "the inverse never holds anywhere." #[test] -fn the_inverse_promotion_never_holds_at_the_direct_site() { - blocked("fn half() -> Result = 10 / 2\n", "int", "half()"); +fn the_inverse_coercion_never_holds() { + blocked( + "fn half() -> Result = 10 / 2\n", + "int", + "half()", + ); } // --------------------------------------------------------------------------- -// Covariance: `out` arguments recurse expected-accepts-actual +// [TYPE-VARIANCE-COERCION] — and never inside an argument position // --------------------------------------------------------------------------- -/// A `Feed` flows into a `Feed>` slot: the covariant -/// argument recurses the promotion. This is the ENTIRE payoff of writing `out`, -/// and nothing in the tree asserted it before. +/// "`Feed` does **not** satisfy a `Feed>` slot, +/// under `out T`" — the coercion would have to rebuild the container. #[test] -fn covariance_carries_the_promotion_into_the_argument() { - flows(FEED, "Feed>", "feedInt()"); +fn a_covariant_argument_does_not_carry_the_coercion() { + blocked(FEED, "Feed>", "feedInt()"); } -/// The unwrapping direction stays refused — "no `Result`-to-`T` coercion -/// at any depth". +/// "…under `in T`" — the flipped recursion does not smuggle it in either. #[test] -fn covariance_never_unwraps_a_result_payload() { - blocked(FEED, "Feed", "feedRes()"); +fn a_contravariant_argument_does_not_carry_the_coercion() { + blocked(GATE, "Gate", "gateRes()"); } -/// The identical instantiation is the baseline both directions are measured -/// against. +/// "…or unannotated." #[test] -fn covariance_accepts_the_identical_instantiation() { - flows(FEED, "Feed", "feedInt()"); -} - -/// Covariance is not "anything goes": an unrelated payload is still refused. -#[test] -fn covariance_rejects_an_unrelated_payload() { - blocked(FEED, "Feed", "feedText()"); - blocked(FEED, "Feed", "feedInt()"); -} - -// --------------------------------------------------------------------------- -// Contravariance: `in` arguments recurse with the roles flipped -// --------------------------------------------------------------------------- - -/// A `Gate>` flows into a `Gate` slot — the flipped -/// recursion, and the entire payoff of writing `in`. -#[test] -fn contravariance_carries_the_promotion_with_the_roles_flipped() { - flows(GATE, "Gate", "gateRes()"); +fn an_invariant_argument_does_not_carry_the_coercion() { + blocked(CELL, "Cell>", "cellInt()"); } -/// The unflipped direction is refused: a gate admitting only `int` cannot stand -/// where one admitting a `Result` is expected. +/// The unwrapping direction is refused under every marker too — the half the +/// shipped fixtures already cover, kept here so both directions sit together. #[test] -fn contravariance_rejects_the_covariant_direction() { +fn no_marker_unwraps_a_result_payload() { + blocked(FEED, "Feed", "feedRes()"); blocked(GATE, "Gate>", "gateInt()"); + blocked(CELL, "Cell", "cellRes()"); } -/// The baseline. +/// The identical instantiation is what all three markers DO accept. #[test] -fn contravariance_accepts_the_identical_instantiation() { +fn every_marker_accepts_the_identical_instantiation() { + flows(FEED, "Feed", "feedInt()"); flows(GATE, "Gate", "gateInt()"); + flows(CELL, "Cell", "cellInt()"); } -/// And it is not "anything goes" either. +/// And an unrelated payload is refused under every marker. #[test] -fn contravariance_rejects_an_unrelated_payload() { +fn every_marker_rejects_an_unrelated_payload() { + blocked(FEED, "Feed", "feedText()"); blocked(GATE, "Gate", "gateText()"); + blocked(CELL, "Cell", "cellText()"); } // --------------------------------------------------------------------------- -// Invariance: arguments unify exactly, in BOTH directions +// Composition — depth does not unlock the coercion // --------------------------------------------------------------------------- -/// An unannotated parameter refuses the promotion the covariant one carries. -/// This test and `covariance_carries_the_promotion_into_the_argument` are the -/// pair that separates a covariant container from an invariant one; the shipped -/// fixtures assert only the half both share. +/// `out` inside `out` recurses, and still bottoms out exact. #[test] -fn invariance_refuses_the_promotion_in_both_directions() { - blocked(CELL, "Cell>", "cellInt()"); - blocked(CELL, "Cell", "cellRes()"); +fn covariance_inside_covariance_still_bottoms_out_exact() { + blocked(NESTED, "Feed>>", "feedFeedInt()"); + flows(NESTED, "Feed>", "feedFeedInt()"); } -/// The baseline. +/// `in` inside `out` flips the recursion — and changes no outcome. #[test] -fn invariance_accepts_the_identical_instantiation() { - flows(CELL, "Cell", "cellInt()"); -} - -// --------------------------------------------------------------------------- -// Composition: "a nested constructor's argument composes the position" -// --------------------------------------------------------------------------- - -/// `out` inside `out` stays covariant, so the promotion reaches two levels down. -#[test] -fn covariance_composes_with_covariance() { - flows(NESTED, "Feed>>", "feedFeedInt()"); -} - -/// `in` inside `out` flips once: the inner argument recurses backwards. -#[test] -fn contravariance_inside_covariance_flips_once() { - flows(NESTED, "Feed>", "feedGateRes()"); -} - -/// …and the unflipped direction stays refused at that depth. -#[test] -fn contravariance_inside_covariance_rejects_the_unflipped_direction() { - blocked(NESTED, "Feed>>", "feedGateInt()"); +fn contravariance_inside_covariance_still_bottoms_out_exact() { + blocked(NESTED, "Feed>", "feedGateRes()"); + blocked( + NESTED, + "Feed>>", + "feedGateInt()", + ); } -/// `out` inside `in` flips the outer relation, so the value travels the other -/// way. +/// `out` inside `in`, the other flip. #[test] -fn covariance_inside_contravariance_flips_once() { - flows(NESTED, "Gate>", "gateFeedRes()"); +fn covariance_inside_contravariance_still_bottoms_out_exact() { + blocked(NESTED, "Gate>", "gateFeedRes()"); } -/// Two flips compose back to covariance. +/// Two flips compose back to covariance, which is still exact. #[test] -fn contravariance_inside_contravariance_composes_back_to_covariance() { - flows(NESTED, "Gate>>", "gateGateInt()"); +fn contravariance_inside_contravariance_still_bottoms_out_exact() { + blocked( + NESTED, + "Gate>>", + "gateGateInt()", + ); + flows(NESTED, "Gate>", "gateGateInt()"); } -/// An invariant argument stops the recursion whatever encloses it. +/// An invariant argument under a covariant one. #[test] -fn an_invariant_argument_stops_the_recursion() { - blocked(NESTED, "Feed>>", "feedCellInt()"); +fn an_invariant_argument_under_a_covariant_one_is_exact() { + blocked( + NESTED, + "Feed>>", + "feedCellInt()", + ); } // --------------------------------------------------------------------------- -// Function payloads: contravariant parameters, covariant returns +// Function payloads: exact under a container, assignable when assigned direct // --------------------------------------------------------------------------- -/// "Function types are structurally contravariant in parameters": a function -/// accepting a `Result` stands where one accepting an `int` is expected. +/// "Function payloads match exactly for the same reason" — the parameter +/// position does not flip inside a container. #[test] -fn a_function_payload_is_contravariant_in_its_parameter() { - flows(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesRes()"); +fn a_function_payload_matches_exactly_inside_a_container() { + blocked(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesRes()"); + blocked( + FNPAYLOAD, + "Feed<(Result) -> bool>", + "feedTakesInt()", + ); } -/// The opposite direction is refused. +/// The spec's own counterexample, and its mirror: neither return direction +/// matches under a container. #[test] -fn a_function_payload_rejects_a_widened_parameter() { - blocked(FNPAYLOAD, "Feed<(Result) -> bool>", "feedTakesInt()"); +fn a_function_payloads_return_matches_exactly_inside_a_container() { + blocked(FNPAYLOAD, "Feed<(int) -> int>", "feedGivesRes()"); + blocked( + FNPAYLOAD, + "Feed<(int) -> Result>", + "feedGivesInt()", + ); } -/// "…and covariant in returns": a function returning `int` stands where one -/// returning `Result` is expected. +/// The identical function payload flows, so the refusals above are about the +/// shape and not about function payloads being rejected wholesale. #[test] -fn a_function_payload_is_covariant_in_its_return() { - flows(FNPAYLOAD, "Feed<(int) -> Result>", "feedGivesInt()"); +fn an_identical_function_payload_flows() { + flows(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesInt()"); } -/// The spec's own counterexample: "a `Feed<(int) -> Result>` does -/// not match a `Feed<(int) -> int>` slot". +// --------------------------------------------------------------------------- +// The agreement test: the consequence, pinned +// --------------------------------------------------------------------------- + +/// "`out T`, `in T` and an unannotated parameter accept and refuse **exactly +/// the same programs** at assignment sites today." +/// +/// This test is the tripwire for that sentence. It goes red the day someone +/// implements a directional relation that actually bites — at which point the +/// spec's consequence paragraph is stale and must be rewritten with it, rather +/// than the language quietly gaining a coercion that reads a payload at the +/// wrong representation. #[test] -fn the_spec_counterexample_stays_refused() { - blocked(FNPAYLOAD, "Feed<(int) -> int>", "feedGivesRes()"); +fn the_three_markers_agree_on_every_assignment_outcome() { + let outcomes: Vec<(&str, bool, bool)> = vec![ + ( + "covariant", + accepted(&sites(FEED, "Feed>", "feedInt()")[0]), + accepted(&sites(FEED, "Feed", "feedRes()")[0]), + ), + ( + "contravariant", + accepted(&sites(GATE, "Gate>", "gateInt()")[0]), + accepted(&sites(GATE, "Gate", "gateRes()")[0]), + ), + ( + "invariant", + accepted(&sites(CELL, "Cell>", "cellInt()")[0]), + accepted(&sites(CELL, "Cell", "cellRes()")[0]), + ), + ]; + for (marker, forward, backward) in &outcomes { + assert!( + !forward && !backward, + "{marker}: expected both directions refused ([TYPE-VARIANCE-COERCION]), \ + got forward={forward} backward={backward}" + ); + } } // --------------------------------------------------------------------------- -// The same relation through the ML surface ([FLAVOR-BOUNDARY]) +// The same rules through the ML surface ([FLAVOR-BOUNDARY]) // --------------------------------------------------------------------------- -/// The ML twin of the covariant payoff. +/// The ML twin: a covariant ML container refuses the coercion too. #[test] -fn ml_covariance_carries_the_promotion_into_the_argument() { - accepts( +fn ml_a_covariant_argument_does_not_carry_the_coercion() { + rejects( Flavor::Ml, "type Feed out T =\n supply : T\n\ feedInt : Unit -> Feed\n\ @@ -278,88 +300,30 @@ fn ml_covariance_carries_the_promotion_into_the_argument() { ); } -/// The ML twin of the contravariant payoff. +/// The ML twin of the identical-instantiation acceptance, so the refusal above +/// is not an ML parsing accident. #[test] -fn ml_contravariance_carries_the_promotion_with_the_roles_flipped() { +fn ml_an_identical_instantiation_flows() { accepts( Flavor::Ml, - "type Gate in T =\n admit : T -> bool\n\ - gateRes : Unit -> Gate>\n\ - gateRes () = Gate(admit = \\x => true)\n\ - takes : Gate -> int\n\ + "type Feed out T =\n supply : T\n\ + feedInt : Unit -> Feed\n\ + feedInt () = Feed(supply = 1)\n\ + takes : Feed -> int\n\ takes v = 0\n\ - held = takes (gateRes ())\n\ + held = takes (feedInt ())\n\ print \"${held}\"\n", ); } -/// The ML twin of the invariant refusal. +/// The ML twin of the direct-site coercion. #[test] -fn ml_invariance_refuses_the_promotion() { - rejects( +fn ml_the_coercion_holds_at_a_direct_value_site() { + accepts( Flavor::Ml, - "type Cell T =\n slot : T\n\ - cellInt : Unit -> Cell\n\ - cellInt () = Cell(slot = 1)\n\ - takes : Cell> -> int\n\ + "takes : Result -> int\n\ takes v = 0\n\ - held = takes (cellInt ())\n\ + held = takes 5\n\ print \"${held}\"\n", ); } - -// --------------------------------------------------------------------------- -// The collapse detector -// --------------------------------------------------------------------------- - -/// True when the checker accepts the program outright. -fn accepted(src: &str) -> bool { - crate::testutil::typecheck(Flavor::Default, src).is_empty() -} - -/// [TYPE-VARIANCE-ASSIGN] opens by saying variance DIRECTS assignability, then -/// closes by saying the recursion "bottoms out in exact unification". Read -/// strictly, the second sentence empties the first: if every leaf must match -/// exactly, `out T`, `in T` and an unannotated parameter accept and refuse -/// exactly the same programs, and the marker's only teeth are -/// [TYPE-VARIANCE-POSITIONS]. -/// -/// This test does not take a side. It asserts only that the two readings are -/// distinguishable in the tree — that SOMETHING about assignment changes when -/// the marker changes. If it fails, the first sentence of [TYPE-VARIANCE-ASSIGN] -/// describes nothing the compiler does and the spec is the stale source; the -/// two shipped fixtures cannot see this, because both assert the one direction -/// all three markers agree on. -#[test] -fn the_marker_must_change_at_least_one_assignment_outcome() { - let covariant = accepted(&sites(FEED, "Feed>", "feedInt()")[0]); - let contravariant = accepted(&sites(GATE, "Gate", "gateRes()")[0]); - let invariant_forward = accepted(&sites(CELL, "Cell>", "cellInt()")[0]); - let invariant_flipped = accepted(&sites(CELL, "Cell", "cellRes()")[0]); - - assert!( - covariant != invariant_forward || contravariant != invariant_flipped, - "variance is inert at assignment sites: out={covariant}, in={contravariant}, \ - invariant={invariant_forward}/{invariant_flipped} — all three markers accept and \ - refuse the same programs, so [TYPE-VARIANCE-ASSIGN]'s directional rule has no \ - observable content and only [TYPE-VARIANCE-POSITIONS] is load-bearing" - ); -} - -/// The other half of the same question, asked of the built-in table: `List` is -/// declared `out` and `Channel` invariant, so at least one program must -/// separate them. -#[test] -fn a_builtin_marker_must_change_at_least_one_assignment_outcome() { - const BUILTINS: &str = "fn listInt() -> List = [1]\n\ - fn chanInt() -> Channel = Channel(2)\n"; - let covariant = accepted(&sites(BUILTINS, "List>", "listInt()")[0]); - let invariant = accepted(&sites(BUILTINS, "Channel>", "chanInt()")[0]); - - assert!( - covariant != invariant, - "`List` and `Channel` are indistinguishable at assignment sites \ - (both {covariant}), so the built-in variance table in [TYPE-VARIANCE-ASSIGN] \ - records nothing the compiler consults" - ); -} diff --git a/crates/osprey-types/src/generics_variance_builtin_tests.rs b/crates/osprey-types/src/generics_variance_builtin_tests.rs index 3b71b62a..70567c51 100644 --- a/crates/osprey-types/src/generics_variance_builtin_tests.rs +++ b/crates/osprey-types/src/generics_variance_builtin_tests.rs @@ -1,19 +1,21 @@ //! The **built-in variance table** of [TYPE-VARIANCE-ASSIGN], asserted through //! the assignment sites rather than read off the declaration -//! (docs/specs/0004-TypeSystem.md). +//! ([TYPE-VARIANCE-COERCION], docs/specs/0004-TypeSystem.md). //! //! "Built-in constructors' declared variance: `Result`, //! `List`, `Fiber`, `Map` (keys invariant); `Channel` //! and `Ptr` are invariant. Function types are structurally contravariant in //! parameters and covariant in returns." //! -//! Each entry in that sentence is a claim about what flows where, so each gets -//! its accepting direction, its refusing direction and its identical-instance -//! baseline — the three together are what distinguish a covariant entry from an -//! invariant one. The relation recursed is the promotion `T -> Result`, -//! whose depth-0 control lives in `generics_variance_assign_tests.rs`. +//! The last sentence is the one with teeth: a function value assigned DIRECTLY +//! matches assignably, parameters flipped and return coerced. The constructor +//! entries above it do not bite today, because the only coercion in the language +//! is representation-changing and therefore barred from argument positions — so +//! `List` and the invariant `Channel` accept and refuse the same +//! programs. Both halves are pinned here: the table's entries are a contract for +//! the day that changes, and the function rules are checked as live behaviour. -use crate::generics_variance_assign_tests::{blocked, flows}; +use crate::generics_variance_assign_tests::{accepted, blocked, flows, sites}; /// Producers for every built-in shape under test, at both instantiations. const BUILTINS: &str = "fn listInt() -> List = [1]\n\ @@ -31,122 +33,69 @@ const BUILTINS: &str = "fn listInt() -> List = [1]\n\ fn givesInt(v: int) = 1\n\ fn givesRes(v: int) = v * 2\n"; -/// Built-ins nested inside each other and inside a declared covariant -/// container, so composition is exercised through the table too. -const NESTED_BUILTINS: &str = "type Feed = Feed { supply: T } | Dry\n\ - type Gate = Gate { admit: (T) -> bool } | Open\n\ - fn listListInt() -> List> = [[1]]\n\ - fn mapListInt() -> Map> = { \"a\": [1] }\n\ - fn resListInt() -> Result, MathError> = [1]\n\ - fn feedListInt() -> Feed> = Feed { supply: [1] }\n\ - fn gateListRes() -> Gate>> = Gate { admit: |x| => true }\n\ - fn gateListInt() -> Gate> = Gate { admit: |x| => true }\n"; - // --------------------------------------------------------------------------- -// List +// The constructor entries: identical instantiations flow, coercions do not // --------------------------------------------------------------------------- -/// A `List` flows into a `List>` slot. +/// `List` accepts its own element type… #[test] -fn list_carries_the_promotion_into_its_element() { - flows(BUILTINS, "List>", "listInt()"); +fn list_accepts_the_identical_element() { + flows(BUILTINS, "List", "listInt()"); } -/// The unwrapping direction is refused. +/// …refuses the coercion in both directions… #[test] -fn list_never_unwraps_its_element() { +fn list_refuses_the_coercion_in_both_directions() { + blocked(BUILTINS, "List>", "listInt()"); blocked(BUILTINS, "List", "listRes()"); } -/// The baseline. -#[test] -fn list_accepts_the_identical_element() { - flows(BUILTINS, "List", "listInt()"); -} - -/// Covariance is not looseness: an unrelated element is refused. +/// …and refuses an unrelated element. #[test] fn list_rejects_an_unrelated_element() { blocked(BUILTINS, "List", "listInt()"); } -// --------------------------------------------------------------------------- -// Result -// --------------------------------------------------------------------------- - -/// The VALUE channel is covariant. +/// `Result`: neither channel carries the coercion inward. #[test] -fn result_carries_the_promotion_into_its_value() { - flows( +fn result_refuses_the_coercion_in_either_channel() { + blocked( BUILTINS, "Result, MathError>", "resInt()", ); -} - -/// The ERROR channel is covariant too — the second half of the table entry, -/// which nothing in the tree exercised. -#[test] -fn result_carries_the_promotion_into_its_error() { - flows( + blocked( BUILTINS, "Result>", "resInt()", ); } -/// Neither channel unwraps. -#[test] -fn result_never_unwraps_either_channel() { - blocked(BUILTINS, "Result", "listRes()"); -} - -// --------------------------------------------------------------------------- -// Fiber -// --------------------------------------------------------------------------- - -/// A `Fiber` flows into a `Fiber>` slot. +/// The identical `Result` instantiation flows. #[test] -fn fiber_carries_the_promotion_into_its_answer() { - flows(BUILTINS, "Fiber>", "fiberInt()"); +fn result_accepts_the_identical_instantiation() { + flows(BUILTINS, "Result", "resInt()"); } -/// The baseline. +/// `Fiber`: same story for a fiber's answer. #[test] -fn fiber_accepts_the_identical_answer() { - flows(BUILTINS, "Fiber", "fiberInt()"); -} - -/// An unrelated answer is refused. -#[test] -fn fiber_rejects_an_unrelated_answer() { +fn fiber_refuses_the_coercion_and_accepts_its_own_answer() { + blocked(BUILTINS, "Fiber>", "fiberInt()"); blocked(BUILTINS, "Fiber", "fiberInt()"); + flows(BUILTINS, "Fiber", "fiberInt()"); } -// --------------------------------------------------------------------------- -// Map — the value is covariant, the key is NOT -// --------------------------------------------------------------------------- - -/// The value channel carries the promotion. -#[test] -fn map_carries_the_promotion_into_its_value() { - flows( - BUILTINS, - "Map>", - "mapInt()", - ); -} - -/// The value channel does not unwrap. +/// `Map`: the value channel refuses the coercion… #[test] -fn map_never_unwraps_its_value() { +fn map_refuses_the_coercion_in_its_value() { + blocked(BUILTINS, "Map>", "mapInt()"); blocked(BUILTINS, "Map", "mapRes()"); } -/// "(keys invariant)" — the key channel refuses the promotion the value channel -/// carries. This pair is the whole content of that parenthesis. +/// …and so does the invariant key channel, which is the entry that would +/// diverge first if argument positions ever started coercing. #[test] -fn map_keys_refuse_the_promotion_in_both_directions() { +fn map_refuses_the_coercion_in_its_key() { blocked( BUILTINS, "Map, int>", @@ -154,35 +103,42 @@ fn map_keys_refuse_the_promotion_in_both_directions() { ); } -/// The baseline. +/// The identical map instantiation flows. #[test] fn map_accepts_the_identical_instantiation() { flows(BUILTINS, "Map", "mapInt()"); } -// --------------------------------------------------------------------------- -// Channel — invariant in both directions -// --------------------------------------------------------------------------- - -/// A channel is written as well as read, so neither direction is safe. +/// `Channel` is invariant, and behaves exactly as the covariant entries do. #[test] -fn channel_refuses_the_promotion_in_both_directions() { +fn channel_refuses_the_coercion_in_both_directions() { blocked(BUILTINS, "Channel>", "chanInt()"); blocked(BUILTINS, "Channel", "chanRes()"); + flows(BUILTINS, "Channel", "chanInt()"); } -/// The baseline. +/// The table's covariant and invariant entries are indistinguishable today — +/// `List` and `Channel` answer identically. This is the built-in twin +/// of `the_three_markers_agree_on_every_assignment_outcome`, and the tripwire +/// for the same spec sentence. #[test] -fn channel_accepts_the_identical_element() { - flows(BUILTINS, "Channel", "chanInt()"); +fn the_covariant_and_invariant_builtins_agree() { + let covariant = accepted(&sites(BUILTINS, "List>", "listInt()")[0]); + let invariant = accepted(&sites(BUILTINS, "Channel>", "chanInt()")[0]); + assert!( + !covariant && !invariant, + "[TYPE-VARIANCE-COERCION] says an argument position never coerces: \ + List(out)={covariant}, Channel(invariant)={invariant}" + ); } // --------------------------------------------------------------------------- -// Function types — contravariant parameters, covariant returns +// Function types — the half of the table that DOES bite // --------------------------------------------------------------------------- -/// A function accepting a `Result` stands where one accepting an `int` is -/// expected: the parameter position is contravariant. +/// "structurally contravariant in parameters": a function accepting a `Result` +/// stands where one accepting an `int` is expected, because the parameter +/// recursion applies the coercion at a direct site. #[test] fn a_function_slot_is_contravariant_in_its_parameter() { flows(BUILTINS, "(int) -> bool", "takesRes"); @@ -194,8 +150,8 @@ fn a_function_slot_rejects_a_widened_parameter() { blocked(BUILTINS, "(Result) -> bool", "takesInt"); } -/// A function returning `int` stands where one returning `Result` is -/// expected: the return position is covariant. +/// "and covariant in returns": a function returning `int` stands where one +/// returning `Result` is expected. #[test] fn a_function_slot_is_covariant_in_its_return() { flows(BUILTINS, "(int) -> Result", "givesInt"); @@ -207,69 +163,34 @@ fn a_function_slot_never_unwraps_its_return() { blocked(BUILTINS, "(int) -> int", "givesRes"); } -/// The baseline. +/// The identical shape flows. #[test] fn a_function_slot_accepts_the_identical_shape() { flows(BUILTINS, "(int) -> bool", "takesInt"); } -// --------------------------------------------------------------------------- -// Composition through the table -// --------------------------------------------------------------------------- - -/// `List` inside `List` stays covariant. -#[test] -fn list_composes_with_list() { - flows( - NESTED_BUILTINS, - "List>>", - "listListInt()", - ); -} - -/// A covariant built-in inside a covariant built-in's value channel. -#[test] -fn map_composes_with_list_in_its_value() { - flows( - NESTED_BUILTINS, - "Map>>", - "mapListInt()", - ); -} - -/// A covariant built-in inside `Result`'s value channel. +/// Arity is checked before any of this. #[test] -fn result_composes_with_list_in_its_value() { - flows( - NESTED_BUILTINS, - "Result>, MathError>", - "resListInt()", - ); +fn a_function_slot_rejects_an_arity_mismatch() { + blocked(BUILTINS, "(int, int) -> bool", "takesInt"); } -/// A built-in inside a DECLARED covariant container: the two tables are one -/// relation, not two. +/// The function rules and the constructor rules are the SAME relation applied +/// at different depths: directly assigned, the parameter coercion works; the +/// identical function wrapped in a `List` argument position does not. #[test] -fn a_declared_covariant_container_composes_with_a_builtin() { - flows( - NESTED_BUILTINS, - "Feed>>", - "feedListInt()", +fn the_function_rules_stop_at_an_argument_position() { + let direct = accepted(&sites(BUILTINS, "(int) -> bool", "takesRes")[0]); + let wrapped = accepted( + &sites( + &format!("{BUILTINS}fn listTakesRes() -> List<(Result) -> bool> = [takesRes]\n"), + "List<(int) -> bool>", + "listTakesRes()", + )[0], ); -} - -/// …and inside a declared CONTRAVARIANT container the composition flips. -#[test] -fn a_declared_contravariant_container_flips_a_builtin() { - flows(NESTED_BUILTINS, "Gate>", "gateListRes()"); -} - -/// The unflipped direction stays refused at that depth. -#[test] -fn a_declared_contravariant_container_rejects_the_unflipped_builtin() { - blocked( - NESTED_BUILTINS, - "Gate>>", - "gateListInt()", + assert!( + direct && !wrapped, + "the parameter coercion must apply at a direct site and NOT inside a \ + `List` argument: direct={direct}, wrapped={wrapped}" ); } diff --git a/crates/osprey-types/src/unify.rs b/crates/osprey-types/src/unify.rs index 7d9759a9..958c3cb8 100644 --- a/crates/osprey-types/src/unify.rs +++ b/crates/osprey-types/src/unify.rs @@ -58,6 +58,15 @@ pub fn unify(ctx: &mut InferCtx, a: &Type, b: &Type) -> Result<(), TypeError> { Ok(()) } + (Type::Con { name, args }, Type::Record { name: actual, fields }) + | (Type::Record { name: actual, fields }, Type::Con { name, args }) + if name == actual => { + match ctx.record_fields(name, args) { + Some(declared) => unify_record(ctx, &declared, fields, &a, &b), + None => Err(TypeError::mismatch(&a, &b)), + } + } + ( Type::Union { name: n1, diff --git a/docs/specs/0004-TypeSystem.md b/docs/specs/0004-TypeSystem.md index 750cd705..124846f7 100644 --- a/docs/specs/0004-TypeSystem.md +++ b/docs/specs/0004-TypeSystem.md @@ -293,12 +293,29 @@ arguments, annotated bindings, return positions), a variance-declared constructor's arguments are matched directionally: covariant (`out`) arguments recurse expected-accepts-actual, contravariant (`in`) arguments recurse with the roles flipped, invariant arguments unify exactly. The -recursion continues only through variance-declared constructors and bottoms -out in **exact unification**. There is no `Result`-to-`T` coercion at any -depth or direct value site: it would erase a failure and accept a value with -the wrong representation. Function returns also match exactly, so a -`Feed<(int) -> Result>` does not match a -`Feed<(int) -> int>` slot. +recursion continues only through **same-name** variance-declared constructors +and bottoms out in **exact unification**. + +`[TYPE-VARIANCE-COERCION]` **The language's one coercion applies at direct +value sites only, never inside a constructor argument.** A bare `T` satisfies a +`Result` slot (an implicit `Success`); the inverse never holds anywhere. +That coercion changes the value's REPRESENTATION, and nothing rebuilds a +container's contents, so it cannot reach through an argument position: +`Feed` does **not** satisfy a `Feed>` slot, under +`out T`, under `in T`, or unannotated. Function payloads match exactly for the +same reason, so a `Feed<(int) -> Result>` does not match a +`Feed<(int) -> int>` slot — while a *directly* assigned function value still +matches assignably, its parameters flipped and its return coerced +(`(Result) -> bool` satisfies an `(int) -> bool` slot). + +**Consequence, stated so no one has to re-derive it:** because that coercion is +the only subtyping the language has, and it is barred from argument positions, +`out T`, `in T` and an unannotated parameter accept and refuse **exactly the +same programs** at assignment sites today. A variance marker's observable effect +is [TYPE-VARIANCE-POSITIONS] — where the parameter may be written — not which +assignments type-check. The directional recursion above is nonetheless +normative: it is what a future representation-PRESERVING subtype relation would +travel through, and the day one exists the three markers stop agreeing. Built-in constructors' declared variance: `Result`, `List`, `Fiber`, `Map` (keys invariant); `Channel` diff --git a/examples/projects/modules/src/domain/json.ospml b/examples/projects/modules/src/domain/json.ospml index a00a4553..accc441d 100644 --- a/examples/projects/modules/src/domain/json.ospml +++ b/examples/projects/modules/src/domain/json.ospml @@ -42,46 +42,37 @@ module Json : JsonApi // Escape original slashes first; later JSON escapes must remain single. // Runtime strings cannot contain NUL, so representable controls start at 1. - escape : string -> string escape s = bslash = "\\" quote = "\"" step = replace s bslash (bslash + bslash) ?: "" escapeControls (replace step quote (bslash + quote) ?: "") 1 - quote : string -> string quote s = quote = "\"" quote + escape s + quote // `"key":"escaped value"` — a string-valued object member. - strField : string -> string -> string strField key value = quote key + ":" + quote value // `"key":123` — a number-valued object member (integers need no escaping). - numField : string -> int -> string numField key value = quote key + ":" + toString value // An already-encoded JSON value. Kept explicit so callers cannot confuse // protocol trees with ordinary escaped application strings. - rawField : string -> string -> string rawField key value = quote key + ":" + value // Wrap a comma-joined member list into an object / array. Callers join the // members with `,`; these only add the braces so nesting stays composable. - obj : string -> string obj members = "{" + members + "}" - arr : string -> string arr elements = "[" + elements + "]" // The one canonical error body shape, so every 4xx path is identical. - error : string -> string error why = obj (strField "error" why) // Scalar-only projection used by the browser model boundary. Documents // are always freed here, so consumers cannot accidentally retain handles. - getOr : string -> string -> string -> string getOr source path fallback = doc = jsonParse source ?: 0 value = jsonGet doc path ?: fallback From 7c5bfec13ea003293a7dd24e67caa465cb3fafcd Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:11:12 +1000 Subject: [PATCH 04/10] fixes --- CLAUDE.md | 10 ++ crates/osprey-ast/src/lib.rs | 2 + crates/osprey-project/src/rewrite.rs | 2 +- crates/osprey-project/src/span.rs | 7 +- crates/osprey-syntax/src/default/expr.rs | 3 +- crates/osprey-syntax/src/ml/cst.rs | 2 + crates/osprey-syntax/src/ml/lower.rs | 3 +- crates/osprey-syntax/src/ml/parser.rs | 3 +- crates/osprey-syntax/src/strings.rs | 1 + crates/osprey-types/src/check.rs | 14 +- crates/osprey-types/src/ctx.rs | 4 +- crates/osprey-types/src/effect_rows.rs | 18 ++- crates/osprey-types/src/env.rs | 5 +- crates/osprey-types/src/expr.rs | 12 +- .../osprey-types/src/generic_effects_tests.rs | 129 +++++++++++++----- .../src/generics_apply_ml_tests.rs | 14 +- .../osprey-types/src/generics_apply_tests.rs | 17 +-- .../src/generics_variance_assign_tests.rs | 2 +- .../src/generics_variance_builtin_tests.rs | 17 ++- .../src/generics_variance_shape_tests.rs | 2 +- .../src/generics_variance_tests.rs | 9 +- docs/plans/0015-generics-and-variance.md | 46 +++++++ ...variance_covariant_no_inward_coercion.ospo | 12 ++ ...ant_no_inward_coercion.ospo.expectedoutput | 1 + .../variance_builtin_no_inward_coercion.ospo | 8 ++ ...tin_no_inward_coercion.ospo.expectedoutput | 1 + ...ance_contravariant_no_inward_coercion.ospo | 12 ++ ...ant_no_inward_coercion.ospo.expectedoutput | 1 + ...variance_covariant_no_inward_coercion.ospo | 15 ++ ...ant_no_inward_coercion.ospo.expectedoutput | 1 + .../type_equality_comprehensive.test.osp | 58 +++++++- ...lity_comprehensive.test.osp.expectedoutput | 1 + .../type_equality_comprehensive.test.ospml | 70 +++++++++- tree-sitter-osprey/test/corpus/osprey.txt | 11 +- 34 files changed, 420 insertions(+), 93 deletions(-) create mode 100644 examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo create mode 100644 examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo.expectedoutput create mode 100644 examples/failscompilation/variance_builtin_no_inward_coercion.ospo create mode 100644 examples/failscompilation/variance_builtin_no_inward_coercion.ospo.expectedoutput create mode 100644 examples/failscompilation/variance_contravariant_no_inward_coercion.ospo create mode 100644 examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput create mode 100644 examples/failscompilation/variance_covariant_no_inward_coercion.ospo create mode 100644 examples/failscompilation/variance_covariant_no_inward_coercion.ospo.expectedoutput diff --git a/CLAUDE.md b/CLAUDE.md index f62b02f0..6ad38eab 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -70,6 +70,16 @@ Silently-wrong output is worse than a crash: a panic is found in seconds; a sile - If removing an annotation still compiles with identical output, it was redundant — remove it. Applies to every `.osp` you touch: `tests/regressions/`, `benchmarks/`, docs and website snippets. - **No consecutive print calls** — consolidate into one interpolated string. +```ospml + // This is wrong because the signature can be inferred. You must omit this! + escape : string -> string + escape s = + bslash = "\\" + quote = "\"" + step = replace s bslash (bslash + bslash) ?: "" + escapeControls (replace step quote (bslash + quote) ?: "") 1 +``` + ## Rust - **Panics are illegal** outside the broken-code quarantine. Return `Result`. diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs index 3b9777d1..863aec3e 100644 --- a/crates/osprey-ast/src/lib.rs +++ b/crates/osprey-ast/src/lib.rs @@ -773,6 +773,8 @@ pub enum Expr { function: Box, /// Written type arguments, in declaration order. type_args: Vec, + /// Source position of the callee, for application diagnostics. + position: Option, }, /// `a |> b` pipe. Pipe { diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs index a9770910..abb67ee9 100644 --- a/crates/osprey-project/src/rewrite.rs +++ b/crates/osprey-project/src/rewrite.rs @@ -288,7 +288,7 @@ impl Resolver<'_> { self.rewrite_expr(left, context, locals); self.rewrite_expr(right, context, locals); } - Expr::TypeApply { function, type_args } => { + Expr::TypeApply { function, type_args, .. } => { self.rewrite_expr(function, context, locals); for argument in type_args { self.rewrite_type(argument, context, locals); diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs index d6ddb229..be116372 100644 --- a/crates/osprey-project/src/span.rs +++ b/crates/osprey-project/src/span.rs @@ -232,7 +232,12 @@ fn offset_expr(expr: &mut Expr, offset: u32) { offset_expr(left, offset); offset_expr(right, offset); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } + Expr::TypeApply { function, type_args, position } => { + shift(position, offset); + for argument in type_args { offset_type(argument, offset); } + offset_expr(function, offset); + } + Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) => offset_expr(operand, offset), diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index cc6e969d..ecc18e79 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -226,6 +226,7 @@ impl Lowerer<'_> { function: Box::new(callee), type_args: self.named_of_kind(args, "type_list").into_iter() .flat_map(|list| self.lower_type_list(list)).collect(), + position: Some(self.pos(node)), }; } match callee { @@ -464,7 +465,7 @@ fn fragment_prefix() -> u32 { } fn parse_fragment(frag: &str) -> Expr { - let parsed = crate::parse_program(&format!("{FRAGMENT_BINDING}{frag}\n")); + let parsed = super::parse(&format!("{FRAGMENT_BINDING}{frag}\n")); if !parsed.errors.is_empty() { return Expr::Identifier(frag.trim().to_owned()); } diff --git a/crates/osprey-syntax/src/ml/cst.rs b/crates/osprey-syntax/src/ml/cst.rs index 5c57f6c2..f90d1248 100644 --- a/crates/osprey-syntax/src/ml/cst.rs +++ b/crates/osprey-syntax/src/ml/cst.rs @@ -481,6 +481,8 @@ pub(crate) enum MlExpr { func: Box, /// Written arguments in binder order. args: Vec, + /// Callee position. + pos: Position, }, /// Zero-argument application `func ()`. UnitApp { diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index a2d470b0..9fbb4d27 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -1079,9 +1079,10 @@ fn lower_expr(expr: MlExpr) -> Expr { segments: path.segments, }), MlExpr::Paren(inner) => lower_expr(*inner), - MlExpr::TypeApply { func, args } => Expr::TypeApply { + MlExpr::TypeApply { func, args, pos } => Expr::TypeApply { function: Box::new(lower_expr(*func)), type_args: args.iter().filter_map(type_expr).collect(), + position: Some(pos), }, // `-literal` folds to the literal so both flavors agree that `-1` is an // `int`, not a fallible `Result` ([ARITH-NEG-LITERAL], [FLAVOR-IR-EQUIV]). diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index 5054780c..309debe9 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -1153,6 +1153,7 @@ impl Parser<'_> { /// Whitespace application `f a b`, left-associative, recorded as nested /// single-argument [`MlExpr::App`] ([FLAVOR-ML-CALL]). fn application(&mut self) -> MlExpr { + let pos = self.pos(); let mut func = self.postfix(); // `Head(field = v, …)` is an inline record literal, not application: any // identifier immediately followed by `(ident = …`. An UPPERCASE head is @@ -1182,7 +1183,7 @@ impl Parser<'_> { if !self.starts_atom() && !self.at_negative_literal_arg() { self.error("type arguments require a call argument"); } - func = MlExpr::TypeApply { func: Box::new(func), args }; + func = MlExpr::TypeApply { func: Box::new(func), args, pos }; } // `f ()` is a zero-argument application, not application to unit. if matches!(self.peek(), TokKind::LParen) && matches!(self.peek_at(1), TokKind::RParen) { diff --git a/crates/osprey-syntax/src/strings.rs b/crates/osprey-syntax/src/strings.rs index 50aa8e04..f0abce5d 100644 --- a/crates/osprey-syntax/src/strings.rs +++ b/crates/osprey-syntax/src/strings.rs @@ -143,6 +143,7 @@ fn rebase_slot(slot: &mut Option, rebase: Rebase) { fn rebase_expr(expr: &mut Expr, rebase: Rebase) { match expr { Expr::List(_, position) + | Expr::TypeApply { position, .. } | Expr::Lambda { position, .. } | Expr::Perform { position, .. } | Expr::Handler { position, .. } => rebase_slot(position, rebase), diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 9602c78b..dccbdcfa 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -706,7 +706,19 @@ impl Checker { let fun_ty = Type::fun(params, ret); let declared = env.applied(&mut self.ctx, name).map(|(_, _, ps)| ps).unwrap_or_default(); env.remove(name); - let scheme = self.generalize_with_obligations(env, &fun_ty); + let mut scheme = self.generalize_with_obligations(env, &fun_ty); + // Explicit binders are quantified even when the signature never uses + // them. Two applications of a phantom binder are still independent. + let env_vars = env.free_vars(&mut self.ctx); + for param in &declared { + let mut vars = BTreeSet::new(); + self.ctx.free_vars(param, &mut vars); + for var in vars.difference(&env_vars) { + if !scheme.vars.contains(var) { + scheme.vars.push(*var); + } + } + } env.insert(name, scheme); env.declare_type_params(name, declared); } diff --git a/crates/osprey-types/src/ctx.rs b/crates/osprey-types/src/ctx.rs index cfd54421..8edcc175 100644 --- a/crates/osprey-types/src/ctx.rs +++ b/crates/osprey-types/src/ctx.rs @@ -7,6 +7,8 @@ use crate::ty::{Type, VarId}; use osprey_ast::Variance; use std::collections::{BTreeSet, HashMap}; +type RecordTemplate = (Vec, Vec<(String, String)>); + /// Holds every type variable's binding. Variable ids are indices into `subst`. #[derive(Debug, Default)] pub struct InferCtx { @@ -16,7 +18,7 @@ pub struct InferCtx { /// [TYPE-VARIANCE-ASSIGN]. variances: HashMap>, /// Nominal record layouts, before instantiating their declaration binders. - records: HashMap, Vec<(String, String)>)>, + records: HashMap, } impl InferCtx { diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index 012b86f5..c7b2affa 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -1335,6 +1335,17 @@ impl Analyzer<'_> { target_level: usize, arguments: &[Option], ) -> Value { + // Substitute the callee's children before inserting caller provenance. + // A replacement already belongs to the caller: walking it again can + // replace its parameter with itself indefinitely for nested records, + // and can also attribute a callback to the wrong lexical binder. + for nested in value.fields.values_mut() { + *nested = self.substitute_value_at(nested.clone(), target_level, arguments); + } + self.substitute_payload_at(&mut value.element, target_level, arguments); + self.substitute_payload_at(&mut value.result_payload, target_level, arguments); + self.substitute_payload_at(&mut value.fiber_payload, target_level, arguments); + value.deferred = self.substitute_summary_at(value.deferred, target_level, arguments); if let Some(callable) = value.callable.take() { match callable { Callable::Parameter { @@ -1384,13 +1395,6 @@ impl Analyzer<'_> { Callable::Unknown => value.callable = Some(Callable::Unknown), } } - for nested in value.fields.values_mut() { - *nested = self.substitute_value_at(nested.clone(), target_level, arguments); - } - self.substitute_payload_at(&mut value.element, target_level, arguments); - self.substitute_payload_at(&mut value.result_payload, target_level, arguments); - self.substitute_payload_at(&mut value.fiber_payload, target_level, arguments); - value.deferred = self.substitute_summary_at(value.deferred, target_level, arguments); value } diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index cb4345a6..aba81407 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -7,6 +7,9 @@ use crate::ctx::InferCtx; use crate::ty::{Scheme, Type, VarId}; use std::collections::{BTreeSet, HashMap, HashSet}; +/// One call's signature, deferred obligations, and ordered declared binders. +pub(crate) type AppliedSignature = (Type, Vec<(String, Type)>, Vec); + /// Maps names to their type schemes. Cloned to form child scopes (lambda /// bodies, match arms) — value semantics, so child bindings never leak out. #[derive(Debug, Clone, Default)] @@ -65,7 +68,7 @@ impl TypeEnv { /// Instantiate the signature and its declared binders with one substitution. pub(crate) fn applied(&self, ctx: &mut InferCtx, name: &str) - -> Option<(Type, Vec<(String, Type)>, Vec)> { + -> Option { let scheme = self.get(name)?; let map = scheme.vars.iter().map(|v| (*v, ctx.fresh())).collect(); let params = self.type_params.get(name).into_iter().flatten() diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index b46f7b7b..afc6a0f1 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -86,7 +86,7 @@ impl Checker { self.infer_negation(&t) } } - Expr::TypeApply { function, type_args } => self.infer_type_application(function, type_args, env).1, + Expr::TypeApply { function, type_args, position } => self.infer_type_application(function, type_args, *position, env).1, Expr::Call { function, arguments, @@ -555,7 +555,7 @@ impl Checker { fn infer_callee(&mut self, function: &Expr, env: &TypeEnv) -> (Option, Type) { match function { - Expr::TypeApply { function, type_args } => self.infer_type_application(function, type_args, env), + Expr::TypeApply { function, type_args, position } => self.infer_type_application(function, type_args, *position, env), Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident(name, env)), Expr::Path(path) => { let name = path.to_string(); @@ -567,7 +567,7 @@ impl Checker { } /// Pin declared binders in this call's fresh instantiation [TYPE-GENERICS-APPLY]. - fn infer_type_application(&mut self, function: &Expr, type_args: &[osprey_ast::TypeExpr], env: &TypeEnv) + fn infer_type_application(&mut self, function: &Expr, type_args: &[osprey_ast::TypeExpr], position: Option, env: &TypeEnv) -> (Option, Type) { let name = match function { Expr::Identifier(name) => name.clone(), @@ -581,14 +581,14 @@ impl Checker { return (Some(name.clone()), self.lookup_ident(&name, env)); }; self.builtin_uses.extend(obligations); - if params.len() != type_args.len() { - self.errors.push(TypeError::new(format!("function `{name}` takes {} type argument(s), got {}", params.len(), type_args.len()))); - } else { + if params.len() == type_args.len() { let binder = self.current_fn_typarams.clone(); for (param, arg) in params.iter().zip(type_args) { let written = crate::convert::type_expr_to_type(arg, &binder); self.push_unify(param, &written); } + } else { + self.errors.push(TypeError::new(format!("function `{name}` takes {} type argument(s), got {}", params.len(), type_args.len())).with_pos(position)); } (Some(name), ty) } diff --git a/crates/osprey-types/src/generic_effects_tests.rs b/crates/osprey-types/src/generic_effects_tests.rs index de7b0c25..0f9eea4e 100644 --- a/crates/osprey-types/src/generic_effects_tests.rs +++ b/crates/osprey-types/src/generic_effects_tests.rs @@ -5,9 +5,14 @@ //! Discharge across instantiations is already exercised by //! `effect_rows_tests.rs`; this module states the parts of the generic-effect //! surface that module does not touch — the DECLARATION's variance positions, -//! the written instantiation spellings (`handle Stash`, -//! `perform Stash.take()`), rows with several generic entries, and the ML -//! twins of each. +//! the instantiation surface (inferred at `handle`/`perform`, WRITTEN only on +//! an effect row), rows with several generic entries, and the ML twins of each. +//! +//! One boundary is easy to get wrong and is pinned below: a written +//! instantiation is legal on a ROW (`!Stash`) and rejected on a dynamic +//! effect's `handle`/`perform` ([STAGE-SIGNALS-EXACT], spec 0035) — that +//! spelling is reserved for `static effect`, where the instantiation IS the +//! identity. use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position_message}; use osprey_syntax::Flavor; @@ -17,16 +22,19 @@ fn op_position_message(param: &str, marker: &str, position: &str, op: &str, owne variance_position_message(param, marker, position, "operation", op, owner) } -/// A generic effect plus a handler that discharges it at `instantiation`. -fn stash_program(instantiation: &str, answer: &str) -> String { +/// A generic effect whose instantiation is INFERRED from the handler arm — the +/// only spelling a dynamic effect accepts, since a written instantiation is +/// rejected by [STAGE-SIGNALS-EXACT] (see +/// `a_written_instantiation_on_a_dynamic_effect_is_rejected`). +fn stash_program(answer: &str) -> String { format!( r#"effect Stash {{ take: fn() -> T }} fn main() -> Unit = {{ - let held = handle Stash{instantiation} + let held = handle Stash take => {answer} - in perform Stash{instantiation}.take() + in perform Stash.take() print("${{held}}") }}"# ) @@ -131,22 +139,32 @@ print("declared")"#, /// "Each handler site instantiates a generic effect independently." #[test] fn a_written_instantiation_is_accepted_on_handle_and_perform() { - accepts(Flavor::Default, &stash_program("", "9")); + accepts(Flavor::Default, &stash_program("9")); } /// The same program at a different instantiation. #[test] fn a_written_string_instantiation_is_accepted() { - accepts(Flavor::Default, &stash_program("", "\"ready\"")); + accepts(Flavor::Default, &stash_program("\"ready\"")); } /// "Handler arm values and performs in the handled body must agree on that -/// instantiation" — an arm answering the wrong type is rejected. +/// instantiation" — an arm answering `string` cannot serve a body whose result +/// is used as an `int`. #[test] -fn a_handler_arm_disagreeing_with_the_written_instantiation_is_rejected() { +fn a_handler_arm_disagreeing_with_the_body_is_rejected() { rejects_with( Flavor::Default, - &stash_program("", "\"ready\""), + r#"effect Stash { + take: fn() -> T +} +fn doubled() -> int = (perform Stash.take()) * 2 ?: 0 +fn main() -> Unit = { + let held = handle Stash + take => "ready" + in doubled() + print("${held}") +}"#, "cannot unify", ); } @@ -154,12 +172,51 @@ fn a_handler_arm_disagreeing_with_the_written_instantiation_is_rejected() { /// The instantiation may also be left to inference at both sites. #[test] fn an_inferred_instantiation_is_accepted() { - accepts(Flavor::Default, &stash_program("", "9")); + accepts(Flavor::Default, &stash_program("9")); +} + +/// A written instantiation on a DYNAMIC effect's `perform` is rejected outright +/// — the spelling belongs to `static effect`, whose identity IS the +/// instantiation ([STAGE-SIGNALS-EXACT], pinned end-to-end by +/// `examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo`). +#[test] +fn a_written_instantiation_on_a_dynamic_perform_is_rejected() { + rejects_with( + Flavor::Default, + r#"effect Stash { + take: fn() -> T +} +fn main() -> Unit = { + let held = handle Stash + take => 9 + in perform Stash.take() + print("${held}") +}"#, + "names an instantiation of dynamic effect", + ); +} + +/// The same restriction at the `handle` site. +#[test] +fn a_written_instantiation_on_a_dynamic_handle_is_rejected() { + rejected_somehow( + Flavor::Default, + r#"effect Stash { + take: fn() -> T +} +fn main() -> Unit = { + let held = handle Stash + take => 9 + in perform Stash.take() + print("${held}") +}"#, + ); } -/// A written `handle Stash` does not discharge a `Stash` perform. +/// A handler discharges only the instantiation it was INFERRED at: a handler +/// answering `int` does not serve a `Stash.put`. #[test] -fn a_written_handler_instantiation_discharges_only_its_own_operations() { +fn an_inferred_handler_instantiation_discharges_only_its_own_operations() { rejected_somehow( Flavor::Default, r#"effect Stash { @@ -167,16 +224,16 @@ fn a_written_handler_instantiation_discharges_only_its_own_operations() { } fn store() = perform Stash.put("text") fn main() -> Unit = { - let done = handle Stash - put v => print("stored") + let done = handle Stash + put v => print("stored ${v + 1 ?: 0}") in store() print("${done}") }"#, ); } -/// Two handlers at two instantiations coexist in ONE program: the sites are -/// independent, not one global instantiation. +/// Two handlers at two instantiations coexist in ONE program: "Each handler +/// site instantiates a generic effect independently", and each infers its own. #[test] fn two_instantiations_of_one_effect_coexist() { accepts( @@ -185,30 +242,32 @@ fn two_instantiations_of_one_effect_coexist() { take: fn() -> T } fn main() -> Unit = { - let n = handle Stash + let n = handle Stash take => 1 - in perform Stash.take() - let s = handle Stash + in perform Stash.take() + let s = handle Stash take => "one" - in perform Stash.take() + in perform Stash.take() print("${n}${s}") }"#, ); } -/// A written instantiation whose arity misses the declaration is rejected. +/// A row's written instantiation IS checked for arity — the row is the surface +/// that keeps the angle spelling, so the count contract lives there. #[test] -fn a_written_effect_instantiation_arity_is_checked() { +fn an_effect_row_instantiation_arity_is_checked() { rejected_somehow( Flavor::Default, r#"effect Stash { - take: fn() -> T + put: fn(T) -> Unit } +fn store() -> Unit !Stash = perform Stash.put(42) fn main() -> Unit = { - let held = handle Stash - take => 1 - in perform Stash.take() - print("${held}") + let done = handle Stash + put v => print("stored") + in store() + print("${done}") }"#, ); } @@ -228,7 +287,7 @@ fn a_row_entry_pins_the_instantiation() { } fn store() -> Unit !Stash = perform Stash.put(42) fn main() -> Unit = { - let done = handle Stash + let done = handle Stash put v => print("stored ${v}") in store() print("${done}") @@ -246,7 +305,7 @@ fn a_body_contradicting_its_pinned_row_is_rejected() { } fn store() -> Unit !Stash = perform Stash.put("text") fn main() -> Unit = { - let done = handle Stash + let done = handle Stash put v => print("stored") in store() print("${done}") @@ -340,7 +399,7 @@ fn ml_rows_apply_arguments_with_angles() { store : Unit -> Unit ! Stash\n\ store () = perform Stash.put 42\n\ main () =\n\ - \x20 done = handle Stash\n\ + \x20 done = handle Stash\n\ \x20 put v => print \"stored\"\n\ \x20 in store ()\n\ \x20 print \"${done}\"\n", @@ -376,9 +435,9 @@ fn ml_a_written_instantiation_is_accepted_on_handle_and_perform() { Flavor::Ml, "effect Stash T\n take : Unit => T\n\ main () =\n\ - \x20 held = handle Stash\n\ + \x20 held = handle Stash\n\ \x20 take => 9\n\ - \x20 in perform Stash.take ()\n\ + \x20 in perform Stash.take ()\n\ \x20 print \"${held}\"\n", ); } diff --git a/crates/osprey-types/src/generics_apply_ml_tests.rs b/crates/osprey-types/src/generics_apply_ml_tests.rs index 6196b6cc..541246ee 100644 --- a/crates/osprey-types/src/generics_apply_ml_tests.rs +++ b/crates/osprey-types/src/generics_apply_ml_tests.rs @@ -244,16 +244,17 @@ print "${{n}} ${{s}}""# } /// Written arguments do not excuse a wrong value argument: applying `Unit` -/// where `int` was pinned still fails. +/// where `int` was pinned still fails. The layer that catches it is not pinned +/// — under curry-by-default this reads as either an arity or a unification +/// failure, and both are truthful rejections. #[test] fn ml_writing_type_arguments_does_not_excuse_the_value_argument() { - rejects_with( + rejected_somehow( Flavor::Ml, &format!( r#"{ML_IDENTITY}pinned = identity () print "${{pinned}}""# ), - "cannot unify", ); } @@ -308,8 +309,7 @@ print "${{chosen}}""# ); } -/// Call-site application and generic-effect instantiation share one `<` rule -/// in ML as well. +/// Call-site application coexists with an inferred generic effect in ML too. #[test] fn ml_type_application_coexists_with_generic_effect_instantiation() { accepts( @@ -318,9 +318,9 @@ fn ml_type_application_coexists_with_generic_effect_instantiation() { r#"effect Stash T take : Unit => T {ML_IDENTITY}main () = - held = handle Stash + held = handle Stash take => identity 9 - in perform Stash.take () + in perform Stash.take () print "${{held}}""# ), ); diff --git a/crates/osprey-types/src/generics_apply_tests.rs b/crates/osprey-types/src/generics_apply_tests.rs index 1f18c894..cd446ad8 100644 --- a/crates/osprey-types/src/generics_apply_tests.rs +++ b/crates/osprey-types/src/generics_apply_tests.rs @@ -150,7 +150,7 @@ fn a_result_type_may_be_a_type_argument() { accepts( Flavor::Default, &format!( - r#"{IDENTITY}let quotient = identity>(10 / 2) + r#"{IDENTITY}let quotient = identity>(20 * 5) print("${{quotient ?: 0}}")"# ), ); @@ -220,11 +220,11 @@ fn a_binder_in_scope_may_be_applied_recursively() { accepts( Flavor::Default, &format!( - r#"fn repeat(value: T, times: int) -> T = match times {{ + r#"fn repeatOf(value: T, times: int) -> T = match times {{ 0 => value - _ => repeat(value, times - 1 ?: 0) + _ => repeatOf(value, times - 1 ?: 0) }} -print("${{repeat(7, 3)}}")"# +print("${{repeatOf(7, 3)}}")"# ), ); } @@ -246,8 +246,9 @@ print("${{chosen}}")"# ); } -/// Call-site application coexists with the generic-EFFECT instantiation syntax -/// that already ships (`perform Stash.take()`): one `<` rule, two sites. +/// Call-site application coexists with a generic effect whose instantiation is +/// INFERRED — a written one is rejected on a dynamic effect ([STAGE-SIGNALS-EXACT]), +/// so the `<` after a callee name must not be read as an effect mention. #[test] fn type_application_coexists_with_generic_effect_instantiation() { accepts( @@ -257,9 +258,9 @@ fn type_application_coexists_with_generic_effect_instantiation() { take: fn() -> T }} {IDENTITY}fn main() -> Unit = {{ - let held = handle Stash + let held = handle Stash take => identity(9) - in perform Stash.take() + in perform Stash.take() print("${{held}}") }}"# ), diff --git a/crates/osprey-types/src/generics_variance_assign_tests.rs b/crates/osprey-types/src/generics_variance_assign_tests.rs index 9990ac8a..b7a3fef3 100644 --- a/crates/osprey-types/src/generics_variance_assign_tests.rs +++ b/crates/osprey-types/src/generics_variance_assign_tests.rs @@ -103,7 +103,7 @@ fn the_coercion_holds_at_a_direct_value_site() { #[test] fn the_inverse_coercion_never_holds() { blocked( - "fn half() -> Result = 10 / 2\n", + "fn half() -> Result = 20 * 5\n", "int", "half()", ); diff --git a/crates/osprey-types/src/generics_variance_builtin_tests.rs b/crates/osprey-types/src/generics_variance_builtin_tests.rs index 70567c51..dbcb24d1 100644 --- a/crates/osprey-types/src/generics_variance_builtin_tests.rs +++ b/crates/osprey-types/src/generics_variance_builtin_tests.rs @@ -22,7 +22,6 @@ const BUILTINS: &str = "fn listInt() -> List = [1]\n\ fn listRes() -> List> = [20 * 5]\n\ fn mapInt() -> Map = { \"a\": 1 }\n\ fn mapRes() -> Map> = { \"a\": 20 * 5 }\n\ - fn mapIntKeys() -> Map = { 1: 2 }\n\ fn resInt() -> Result = 20 * 5\n\ fn one() = 1\n\ fn fiberInt() -> Fiber = spawn one()\n\ @@ -92,15 +91,15 @@ fn map_refuses_the_coercion_in_its_value() { blocked(BUILTINS, "Map", "mapRes()"); } -/// …and so does the invariant key channel, which is the entry that would -/// diverge first if argument positions ever started coercing. +/// The key channel cannot be exercised for variance at all: the shipped map +/// surface fixes keys to `string` ([BUILTIN-MAP-GET], spec 0012), so +/// `Map` has no producer and `Map`'s "(keys invariant)" +/// describes a parameter no program can instantiate. Recorded as a spec/ +/// implementation conflict in plan 0015 rather than asserted as behaviour; what +/// IS assertable is that a non-string key is refused. #[test] -fn map_refuses_the_coercion_in_its_key() { - blocked( - BUILTINS, - "Map, int>", - "mapIntKeys()", - ); +fn a_non_string_map_key_is_refused() { + blocked(BUILTINS, "Map", "mapInt()"); } /// The identical map instantiation flows. diff --git a/crates/osprey-types/src/generics_variance_shape_tests.rs b/crates/osprey-types/src/generics_variance_shape_tests.rs index f027b757..59395391 100644 --- a/crates/osprey-types/src/generics_variance_shape_tests.rs +++ b/crates/osprey-types/src/generics_variance_shape_tests.rs @@ -71,7 +71,7 @@ fn map_keys_refuse_both_markers() { /// A record that both holds and consumes its parameter demands both /// directions, so only an invariant parameter fits. fn both_positions(params: &str) -> String { - format!("type Holder{params} = {{{{ held: T, consume: (T) -> int }}}}\nprint(\"declared\")") + format!("type Holder{params} = {{ held: T, consume: (T) -> int }}\nprint(\"declared\")") } /// The invariant spelling is accepted. diff --git a/crates/osprey-types/src/generics_variance_tests.rs b/crates/osprey-types/src/generics_variance_tests.rs index cf00aa4a..a8e38e76 100644 --- a/crates/osprey-types/src/generics_variance_tests.rs +++ b/crates/osprey-types/src/generics_variance_tests.rs @@ -122,13 +122,14 @@ fn out_inside_a_contravariant_constructor_argument_is_rejected() { ); } -/// The mirror: `in T` inside a contravariant argument lands in output. +/// The mirror composes the other way and is LEGAL: a field is an output +/// position, the contravariant argument flips it to input, and an input +/// position is exactly where `in T` belongs (output x contravariant = input). #[test] -fn in_inside_a_contravariant_constructor_argument_is_rejected() { - rejects_with( +fn in_inside_a_contravariant_constructor_argument_is_legal() { + accepts( Flavor::Default, &format!("type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate")), - &position_message("T", "in", "output", "nested", "Holder"), ); } diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index e6f5bd75..2db282c7 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -188,6 +188,52 @@ its HM generalization rules remain separate work in concrete use case is specified. - **Higher-kinded type parameters** (`F<_>`): not represented, not planned. +## Conflicts found while pinning the spec (2026-09-09) + +Four disagreements surfaced when the generics surface was written down as +executable assertions. Each is recorded with the evidence that settles it. + +1. **Variance was inert at assignment sites, and the spec implied otherwise.** + `[TYPE-VARIANCE-ASSIGN]` opened with a directional rule and closed with + "bottoms out in exact unification". `unify_variant_arg` + (`crates/osprey-types/src/unify.rs`) recurses only through **same-name** + variance-declared constructors and then calls plain `unify`, so `int` versus + `Result` is an exact mismatch at any depth. The one coercion + in the language (`T -> Result`) is representation-changing and applies + at direct value sites only. **Resolution:** exact leaves win; spec 0004 now + says so in `[TYPE-VARIANCE-COERCION]`, and states the consequence outright — + `out`, `in` and unannotated accept and refuse the same programs today, so a + marker's observable effect is position checking alone. Pinned by + `the_three_markers_agree_on_every_assignment_outcome` and + `the_covariant_and_invariant_builtins_agree`, which go red the day a + representation-preserving subtype relation lands without a spec update. + The two shipped fixtures could not see this: both assert the one direction + all three markers already agree on. + +2. **`Map`'s "(keys invariant)" describes an uninstantiable + parameter.** The shipped map surface fixes keys to `string` + ([BUILTIN-MAP-GET], spec 0012), so no program can write `Map` and + the key's variance is unobservable. Spec 0004's built-in table and spec 0012 + disagree about whether `K` exists. + +3. **The dynamic-instantiation diagnostic contradicts the runtime it cites.** + `examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo` + rejects `perform Signal` on a dynamic effect because "a dynamic + handler is keyed by effect name at runtime, so instantiations share one + key" — but `crates/osprey-codegen/src/effects.rs` registers each handler + "under its instantiation-mangled key, so only same-instantiation performs + resolve to it", which is also what spec 0017 `[EFFECTS-GENERIC-RUNTIME]` + promises. The REJECTION is a shipped contract and stands; its stated REASON + is stale and would mislead anyone implementing against it. The surface rule + is now pinned as: `handle`/`perform` infer a dynamic effect's instantiation, + angles are legal on a ROW (`!Stash`), and the written mention belongs + to `static effect`, whose identity IS the instantiation. + +4. **Spec 0017 writes `handle … do`; the language accepts `in`.** Intended: + the Default flavor is moving to `do` ([plan 0027](0027-arithmetic-effects.md) + phase 0). `the_spec_writes_a_handled_body_after_do` is a deliberate red pin + that turns green when that rename lands. + ## TODO Core (done): diff --git a/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo new file mode 100644 index 00000000..34447d5f --- /dev/null +++ b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo @@ -0,0 +1,12 @@ +(** The ML surface lowers to the same canonical nodes, so the coercion stops at + the same boundary. Implements [TYPE-VARIANCE-COERCION], [FLAVOR-ML-GENERICS] *) +type Feed out T = + supply : T + +feedInt : Unit -> Feed +feedInt () = Feed(supply = 1) + +total : Feed> -> int +total f = f.supply ?: 0 + +main () = print "${total (feedInt ())}" diff --git a/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo.expectedoutput b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo.expectedoutput new file mode 100644 index 00000000..6207037d --- /dev/null +++ b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo.expectedoutput @@ -0,0 +1 @@ +type mismatch: cannot unify Result with int diff --git a/examples/failscompilation/variance_builtin_no_inward_coercion.ospo b/examples/failscompilation/variance_builtin_no_inward_coercion.ospo new file mode 100644 index 00000000..9a242cbb --- /dev/null +++ b/examples/failscompilation/variance_builtin_no_inward_coercion.ospo @@ -0,0 +1,8 @@ +// `List` is a covariant built-in and still matches its element exactly: +// a List stores raw ints, and reading them as Results would misread every +// element. Implements [TYPE-VARIANCE-COERCION] +fn listInt() -> List = [1, 2] + +fn total(items: List>) = length(items) + +fn main() -> Unit = print("${total(listInt())}") diff --git a/examples/failscompilation/variance_builtin_no_inward_coercion.ospo.expectedoutput b/examples/failscompilation/variance_builtin_no_inward_coercion.ospo.expectedoutput new file mode 100644 index 00000000..6207037d --- /dev/null +++ b/examples/failscompilation/variance_builtin_no_inward_coercion.ospo.expectedoutput @@ -0,0 +1 @@ +type mismatch: cannot unify Result with int diff --git a/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo new file mode 100644 index 00000000..05c433d5 --- /dev/null +++ b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo @@ -0,0 +1,12 @@ +// The flipped recursion of `in T` does not smuggle the coercion in either: the +// leaves still match exactly, so a Gate> is not a +// Gate. Implements [TYPE-VARIANCE-COERCION] +type Gate = Gate { admit: (T) -> bool } | Open + +fn gateRes() -> Gate> = Gate { admit: |x| => true } +fn describe(g: Gate) = match g { + Gate { admit } => "guarded" + Open => "open" +} + +fn main() -> Unit = print(describe(gateRes())) diff --git a/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput new file mode 100644 index 00000000..5d5e6776 --- /dev/null +++ b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput @@ -0,0 +1 @@ +type mismatch: cannot unify int with Result diff --git a/examples/failscompilation/variance_covariant_no_inward_coercion.ospo b/examples/failscompilation/variance_covariant_no_inward_coercion.ospo new file mode 100644 index 00000000..d942a5a7 --- /dev/null +++ b/examples/failscompilation/variance_covariant_no_inward_coercion.ospo @@ -0,0 +1,15 @@ +// The bare-to-Success coercion is representation-changing, so it applies at a +// DIRECT value site and never inside a constructor argument: a Feed holds +// a raw int where a Feed> holds a Result, and nothing +// rebuilds the container. `out T` does not change that — the shipped fixture +// variance_covariant_result_payload.ospo covers the unwrapping direction; this +// is the widening one. Implements [TYPE-VARIANCE-COERCION] +type Feed = Feed { supply: T } | Dry + +fn feedInt() -> Feed = Feed { supply: 1 } +fn total(f: Feed>) = match f { + Feed { supply } => supply ?: 0 + Dry => 0 +} + +fn main() -> Unit = print("${total(feedInt())}") diff --git a/examples/failscompilation/variance_covariant_no_inward_coercion.ospo.expectedoutput b/examples/failscompilation/variance_covariant_no_inward_coercion.ospo.expectedoutput new file mode 100644 index 00000000..6207037d --- /dev/null +++ b/examples/failscompilation/variance_covariant_no_inward_coercion.ospo.expectedoutput @@ -0,0 +1 @@ +type mismatch: cannot unify Result with int diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.osp b/tests/regressions/basics/types/type_equality_comprehensive.test.osp index 86ed8a3e..c79a228a 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.osp +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.osp @@ -112,6 +112,26 @@ fn mkGate() -> Gate<(int) -> Result> = Gate { admit: |f| => true print("fn-payload feed accepted: ${label(mkFeed())}") print("fn-payload gate accepted: ${describe(mkGate())}") +/// --- Variance positions: every legal shape, exercised end to end --- +/// `out T` sits in a field, a function RESULT, a covariant built-in and under +/// two parameter flips; `in T` sits in a function parameter; an unannotated +/// parameter sits in both at once. Each value is then USED, so a position that +/// merely compiled but lowered wrongly is caught as well as one that was +/// wrongly rejected. Assignment keeps the leaves exact under every marker — +/// the refusals are in examples/failscompilation/variance_*.ospo. +/// Implements [TYPE-VARIANCE-POSITIONS], [TYPE-VARIANCE-COERCION] +type Source = Source { produce: T, make: (int) -> T, items: List } +type Sink = Sink { admit: (T) -> bool, hof: ((T) -> int) -> int } +type Both = Both { slot: T, consume: (T) -> int } + +fn srcInt() -> Source = Source { produce: 4, make: |n| => n, items: [1, 2] } +fn sinkInt() -> Sink = Sink { admit: |x| => true, hof: |f| => 7 } +fn bothInt() -> Both = Both { slot: 5, consume: |x| => 6 } +fn keepSource(s: Source) = s.produce +fn keepSink(g: Sink) = g.hof(|n| => 3) + +print("variance produce=${srcInt().produce} make=${srcInt().make(9)} items=${length(srcInt().items)} admit=${toString(sinkInt().admit(1))} slot=${bothInt().slot} kept=${keepSource(srcInt())}/${keepSink(sinkInt())}") + /// --- Call-site type application: pinning an instantiation in the source --- /// A written type-argument list pins the callee's declared binders left to /// right and is checked against what the value arguments infer. `emptyOf`'s @@ -121,6 +141,12 @@ print("fn-payload gate accepted: ${describe(mkGate())}") fn identityOf(x: T) -> T = x fn emptyOf() -> List = [] fn pickOf(first: T, second: U) -> T = first +fn alsoOf(x: T, f: (T) -> T) -> T = f(x) +fn headOr(items: List, fallback: T) -> T = items.listGet(0) ?: fallback +fn repeatOf(value: T, times: int) -> T = match times { + 0 => value + _ => repeatOf(value, times - 1 ?: 0) +} let appliedInt = identityOf(5) let appliedText = identityOf("os") @@ -160,7 +186,37 @@ fn typeEqualityCase() = { identityOf("os") == "os", length(identityOf>([1, 2])) == 2, length(emptyOf()) == 0, - pickOf(7, "seven") == 7 + pickOf(7, "seven") == 7, + identityOf(true), + !identityOf(false), + identityOf(2.5) == 2.5, + length(identityOf>(["a", "b"])) == 2, + mapLength(identityOf>>({ "a": [1], "b": [2] })) == 2, + identityOf>(Container { value: 9 }).value == 9, + identityOf>(Container { value: "c" }).value == "c", + isEmpty(emptyOf()), + pickOf("first", 2) == "first", + pickOf(3, 4) == 3, + alsoOf(21, timesTwo) == 42, + identityOf<(int) -> int>(timesTwo)(21) == 42, + applyInt(f: identityOf<(int) -> int>(addOne), x: 9) == 10, + [4, 5].headOr(0) == 4, + headOr([], 9) == 9, + headOr(["a"], "z") == "a", + repeatOf(7, 3) == 7, + repeatOf("os", 2) == "os", + (identityOf>(20 * 5) ?: 0) == 100, + identityOf(identityOf(6)) == 6, + srcInt().produce == 4, + srcInt().make(9) == 9, + length(srcInt().items) == 2, + (srcInt().items.listGet(1) ?: 0) == 2, + sinkInt().admit(1), + sinkInt().hof(|n| => 3) == 7, + bothInt().slot == 5, + bothInt().consume(1) == 6, + keepSource(srcInt()) == 4, + keepSink(sinkInt()) == 7 ]) } test("equivalent type shapes compose while union tags remain distinct", typeEqualityCase) diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput b/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput index cc6f4b2f..0bc1fe0f 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.osp.expectedoutput @@ -25,6 +25,7 @@ sameRR=true sameRB=false fn-payload feed accepted: supplied fn-payload gate accepted: guarded +variance produce=4 make=9 items=2 admit=true slot=5 kept=4/7 applied int=5 text=os nested=2 empty=0 pair=7 === TYPE EQUALITY COMPLETE === ok 1 - equivalent type shapes compose while union tags remain distinct diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml index 80e8c869..63c0571a 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml @@ -136,6 +136,36 @@ mkGate () = Gate(admit = \f => true) print "fn-payload feed accepted: ${label (mkFeed ())}" print "fn-payload gate accepted: ${describe (mkGate ())}" +(** --- Variance positions: every legal shape, exercised end to end --- + `out T` sits in a field, a function RESULT, a covariant built-in and under + two parameter flips; `in T` sits in a function parameter; an unannotated + parameter sits in both at once. Each value is then USED, so a position that + merely compiled but lowered wrongly is caught as well as one that was + wrongly rejected. Assignment keeps the leaves exact under every marker. + Implements [TYPE-VARIANCE-POSITIONS], [TYPE-VARIANCE-COERCION], + [FLAVOR-ML-GENERICS] *) +type Source out T = + produce : T + make : (int) -> T + items : List +type Sink in T = + admit : (T) -> bool + hof : ((T) -> int) -> int +type Both T = + slot : T + consume : (T) -> int + +srcInt : Unit -> Source +srcInt () = Source(produce = 4, make = \n => n, items = [1, 2]) +sinkInt : Unit -> Sink +sinkInt () = Sink(admit = \x => true, hof = \f => 7) +bothInt : Unit -> Both +bothInt () = Both(slot = 5, consume = \x => 6) +keepSource s = s.produce +keepSink g = g.hof (\n => 3) + +print "variance produce=${(srcInt ()).produce} make=${(srcInt ()).make 9} items=${length (srcInt ()).items} admit=${toString ((sinkInt ()).admit 1)} slot=${(bothInt ()).slot} kept=${keepSource (srcInt ())}/${keepSink (sinkInt ())}" + (** --- Call-site type application: pinning an instantiation in the source --- A written type-argument list pins the callee's declared binders left to right and is checked against what the value arguments infer. `emptyOf`'s @@ -148,6 +178,14 @@ emptyOf : Unit -> List emptyOf () = [] pickOf : (T, U) -> T pickOf (first, second) = first +alsoOf : (T, (T) -> T) -> T +alsoOf (x, f) = f x +headOr : (List, T) -> T +headOr (items, fallback) = listGet items 0 ?: fallback +repeatOf : (T, int) -> T +repeatOf (value, times) = match times + 0 => value + _ => repeatOf (value, times - 1 ?: 0) appliedInt = identityOf 5 appliedText = identityOf "os" @@ -187,6 +225,36 @@ typeEqualityCase () = identityOf "os" == "os", length (identityOf> [1, 2]) == 2, length (emptyOf ()) == 0, - pickOf (7, "seven") == 7 + pickOf (7, "seven") == 7, + identityOf true, + !(identityOf false), + identityOf 2.5 == 2.5, + length (identityOf> ["a", "b"]) == 2, + mapLength (identityOf>> { "a": [1], "b": [2] }) == 2, + (identityOf> (Container(value = 9))).value == 9, + (identityOf> (Container(value = "c"))).value == "c", + isEmpty (emptyOf ()), + pickOf ("first", 2) == "first", + pickOf (3, 4) == 3, + alsoOf (21, timesTwo) == 42, + (identityOf<(int) -> int> timesTwo) 21 == 42, + applyInt (identityOf<(int) -> int> addOne, 9) == 10, + ([4, 5] |> headOr 0) == 4, + headOr ([], 9) == 9, + headOr (["a"], "z") == "a", + repeatOf (7, 3) == 7, + repeatOf ("os", 2) == "os", + (identityOf> (20 * 5) ?: 0) == 100, + identityOf (identityOf 6) == 6, + (srcInt ()).produce == 4, + (srcInt ()).make 9 == 9, + length (srcInt ()).items == 2, + (listGet (srcInt ()).items 1 ?: 0) == 2, + (sinkInt ()).admit 1, + (sinkInt ()).hof (\n => 3) == 7, + (bothInt ()).slot == 5, + (bothInt ()).consume 1 == 6, + keepSource (srcInt ()) == 4, + keepSink (sinkInt ()) == 7 ] test "equivalent type shapes compose while union tags remain distinct" typeEqualityCase diff --git a/tree-sitter-osprey/test/corpus/osprey.txt b/tree-sitter-osprey/test/corpus/osprey.txt index 93d8dbc5..359bbc52 100644 --- a/tree-sitter-osprey/test/corpus/osprey.txt +++ b/tree-sitter-osprey/test/corpus/osprey.txt @@ -685,11 +685,12 @@ fn main() = identity>([1]) (argument_list (expression (primary_expression - (list_literal - (expression - (primary_expression - (literal - (integer)))))))))))) + (literal + (list_literal + (expression + (primary_expression + (literal + (integer))))))))))))) ================================================================================ A spaced comparison is not type application [TYPE-GENERICS-APPLY] From 93f3c4bcc868d949f65de6107a9a0274b7c9cc22 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:14:23 +1000 Subject: [PATCH 05/10] fixes --- crates/osprey-ast/src/freevars.rs | 5 +- crates/osprey-ast/src/mutate.rs | 5 +- crates/osprey-ast/src/resume.rs | 10 +- crates/osprey-ast/src/stage.rs | 2 +- crates/osprey-ast/src/visit.rs | 5 +- crates/osprey-project/src/rewrite.rs | 6 +- crates/osprey-project/src/span.rs | 10 +- crates/osprey-project/src/state.rs | 7 +- crates/osprey-syntax/src/default/expr.rs | 7 +- crates/osprey-syntax/src/default/mod.rs | 20 + crates/osprey-syntax/src/ml/parser.rs | 6 +- .../osprey-types/src/builtin_constraints.rs | 3 + crates/osprey-types/src/check.rs | 93 +- crates/osprey-types/src/ctx.rs | 29 +- crates/osprey-types/src/effect_rows.rs | 24 +- crates/osprey-types/src/env.rs | 19 +- crates/osprey-types/src/expr.rs | 86 +- crates/osprey-types/src/unify.rs | 25 +- docs/plans/0015-generics-and-variance.md | 9 + tree-sitter-osprey/grammar.js | 6 +- tree-sitter-osprey/src/grammar.json | 107 +- tree-sitter-osprey/src/node-types.json | 21 +- tree-sitter-osprey/src/parser.c | 36341 ++++++++-------- 23 files changed, 18757 insertions(+), 18089 deletions(-) diff --git a/crates/osprey-ast/src/freevars.rs b/crates/osprey-ast/src/freevars.rs index 1542ccea..0405bca3 100644 --- a/crates/osprey-ast/src/freevars.rs +++ b/crates/osprey-ast/src/freevars.rs @@ -58,7 +58,10 @@ fn walk(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { walk(left, bound, out); walk(right, bound, out); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => walk(operand, bound, out), + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } => walk(operand, bound, out), e2 => walk_rest(e2, bound, out), } } diff --git a/crates/osprey-ast/src/mutate.rs b/crates/osprey-ast/src/mutate.rs index 04a78a9c..5d84bfef 100644 --- a/crates/osprey-ast/src/mutate.rs +++ b/crates/osprey-ast/src/mutate.rs @@ -45,7 +45,10 @@ pub fn children_mut(expression: &mut Expr, visit: &mut impl FnMut(&mut Expr)) { visit(left); visit(right); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) diff --git a/crates/osprey-ast/src/resume.rs b/crates/osprey-ast/src/resume.rs index 64b500ea..4ed96a53 100644 --- a/crates/osprey-ast/src/resume.rs +++ b/crates/osprey-ast/src/resume.rs @@ -30,7 +30,10 @@ pub fn contains_resume(e: &Expr) -> bool { Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { contains_resume(left) || contains_resume(right) } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => contains_resume(operand), + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } => contains_resume(operand), Expr::Call { function, arguments, @@ -153,7 +156,10 @@ fn sequential_children(body: &Expr) -> u32 { Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { resumes_on_one_path(left) + resumes_on_one_path(right) } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } => resumes_on_one_path(operand), + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } => resumes_on_one_path(operand), Expr::Call { function, arguments, diff --git a/crates/osprey-ast/src/stage.rs b/crates/osprey-ast/src/stage.rs index a3ed12b9..4bf1b7d5 100644 --- a/crates/osprey-ast/src/stage.rs +++ b/crates/osprey-ast/src/stage.rs @@ -297,7 +297,7 @@ fn instantiation_errors( if declared.stage == Stage::Dynamic { return vec![StageError::new( format!( - "`{site} {effect}` names an instantiation of dynamic effect `{base}`; a dynamic handler is keyed by effect name at runtime, so instantiations share one key and cannot be told apart (docs/plans/0024-staged-effects.md). Declare `static effect {base}`, or write `{site} {base}` and let inference instantiate it" + "`{site} {effect}` names an instantiation of dynamic effect `{base}`; a written instantiation is the identity of a `static effect`, while a dynamic effect takes its instantiation from inference (docs/plans/0024-staged-effects.md). Declare `static effect {base}`, or write `{site} {base}` and let inference instantiate it" ), position, )]; diff --git a/crates/osprey-ast/src/visit.rs b/crates/osprey-ast/src/visit.rs index 5d715c99..0d8d1d5f 100644 --- a/crates/osprey-ast/src/visit.rs +++ b/crates/osprey-ast/src/visit.rs @@ -99,7 +99,10 @@ fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec pending.push(Node::Expression(right)); pending.push(Node::Expression(left)); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) | Expr::Recv(operand) => pending.push(Node::Expression(operand)), diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs index abb67ee9..ef25a22c 100644 --- a/crates/osprey-project/src/rewrite.rs +++ b/crates/osprey-project/src/rewrite.rs @@ -288,7 +288,11 @@ impl Resolver<'_> { self.rewrite_expr(left, context, locals); self.rewrite_expr(right, context, locals); } - Expr::TypeApply { function, type_args, .. } => { + Expr::TypeApply { + function, + type_args, + .. + } => { self.rewrite_expr(function, context, locals); for argument in type_args { self.rewrite_type(argument, context, locals); diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs index be116372..440d8ee1 100644 --- a/crates/osprey-project/src/span.rs +++ b/crates/osprey-project/src/span.rs @@ -232,9 +232,15 @@ fn offset_expr(expr: &mut Expr, offset: u32) { offset_expr(left, offset); offset_expr(right, offset); } - Expr::TypeApply { function, type_args, position } => { + Expr::TypeApply { + function, + type_args, + position, + } => { shift(position, offset); - for argument in type_args { offset_type(argument, offset); } + for argument in type_args { + offset_type(argument, offset); + } offset_expr(function, offset); } Expr::Unary { operand, .. } diff --git a/crates/osprey-project/src/state.rs b/crates/osprey-project/src/state.rs index 0d11b8a2..8a6d8ab9 100644 --- a/crates/osprey-project/src/state.rs +++ b/crates/osprey-project/src/state.rs @@ -229,7 +229,12 @@ impl<'a> Inspector<'a> { self.expr(left, in_owner_arm, position); self.expr(right, in_owner_arm, position); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } | Expr::Await(operand) | Expr::Recv(operand) => { + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } + | Expr::Await(operand) + | Expr::Recv(operand) => { self.expr(operand, in_owner_arm, position); } Expr::Spawn(operand) => self.escaping(operand, position), diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index ecc18e79..43482af5 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -224,8 +224,11 @@ impl Lowerer<'_> { } callee = Expr::TypeApply { function: Box::new(callee), - type_args: self.named_of_kind(args, "type_list").into_iter() - .flat_map(|list| self.lower_type_list(list)).collect(), + type_args: self + .named_of_kind(args, "type_list") + .into_iter() + .flat_map(|list| self.lower_type_list(list)) + .collect(), position: Some(self.pos(node)), }; } diff --git a/crates/osprey-syntax/src/default/mod.rs b/crates/osprey-syntax/src/default/mod.rs index 53b04a2e..3d9d6179 100644 --- a/crates/osprey-syntax/src/default/mod.rs +++ b/crates/osprey-syntax/src/default/mod.rs @@ -67,6 +67,10 @@ pub fn parse_tree(source: &str) -> Option { } fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) { + if let Some(error) = call_variance_error(node, src) { + out.push(error); + return; + } if node.is_error() || node.is_missing() { let p = node.start_position(); out.push(SyntaxError { @@ -113,6 +117,22 @@ fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) { } } +/// Variance declares a binder; it cannot decorate a call's type argument. +fn call_variance_error(node: Node<'_>, src: &[u8]) -> Option { + if node.kind() != "call_expression" { + return None; + } + let args = node.child_by_field_name("type_arguments")?; + let list = args.named_child(0)?; + let marker = list.child_by_field_name("variance")?; + let argument = marker.next_named_sibling()?.utf8_text(src).ok()?; + let callee = node.child_by_field_name("callee")?.utf8_text(src).ok()?; + Some(SyntaxError { + message: format!("variance annotations are only valid on type and effect declarations; remove the marker from `{argument}` at the call to `{callee}`"), + position: position_from_point(node.start_position()), + }) +} + fn is_negative_numeric(node: Node<'_>, src: &[u8]) -> bool { let mut ancestor = node.parent(); while let Some(parent) = ancestor { diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index 309debe9..0e12deb4 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -1183,7 +1183,11 @@ impl Parser<'_> { if !self.starts_atom() && !self.at_negative_literal_arg() { self.error("type arguments require a call argument"); } - func = MlExpr::TypeApply { func: Box::new(func), args, pos }; + func = MlExpr::TypeApply { + func: Box::new(func), + args, + pos, + }; } // `f ()` is a zero-argument application, not application to unit. if matches!(self.peek(), TokKind::LParen) && matches!(self.peek_at(1), TokKind::RParen) { diff --git a/crates/osprey-types/src/builtin_constraints.rs b/crates/osprey-types/src/builtin_constraints.rs index 72b1ef91..f55b89cf 100644 --- a/crates/osprey-types/src/builtin_constraints.rs +++ b/crates/osprey-types/src/builtin_constraints.rs @@ -31,6 +31,9 @@ pub(crate) fn display_param_type(name: &str, index: usize) -> Option<&'static st /// Validate the receiver/value of a representation-sensitive built-in. pub(crate) fn invalid_use(name: &str, ty: &Type) -> Option { match name { + "interpolation" if matches!(ty, Type::Fun { .. }) && crate::ty::has_type_var(ty) => Some( + "a closure value with a still-generic type cannot be interpolated; apply it or give it a concrete function type".to_owned() + ), "length" | "isEmpty" if !is_sized(ty) => Some(format!( "`{name}` supports only string, List, or Map; got {ty}" )), diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index dccbdcfa..d3db158a 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -424,7 +424,8 @@ impl Checker { .map(|f| (f.name.clone(), f.ty.clone())) .collect(); if is_record { - self.ctx.set_record(name.to_owned(), param_names.clone(), fields.clone()); + self.ctx + .set_record(name.to_owned(), param_names.clone(), fields.clone()); } let _ = self.ctors.insert( v.name.clone(), @@ -603,7 +604,10 @@ impl Checker { for tp in type_params { let v = self.ctx.fresh(); if typarams.insert(tp.name.clone(), v).is_some() { - self.errors.push(TypeError::new(format!("duplicate type parameter `{}`", tp.name))); + self.errors.push(TypeError::new(format!( + "duplicate type parameter `{}`", + tp.name + ))); } } let params: Vec = parameters @@ -617,7 +621,10 @@ impl Checker { Some(te) => type_expr_to_type(te, &typarams), None => self.ctx.fresh(), }; - let ordered = type_params.iter().filter_map(|p| typarams.get(&p.name).cloned()).collect(); + let ordered = type_params + .iter() + .filter_map(|p| typarams.get(&p.name).cloned()) + .collect(); let _ = self.fn_typarams.insert(name.to_string(), typarams); self.publish_signature(name, parameters, params, ret, env); env.declare_type_params(name, ordered); @@ -704,7 +711,10 @@ impl Checker { // variables would count as "free in the environment" and nothing would // generalize. let fun_ty = Type::fun(params, ret); - let declared = env.applied(&mut self.ctx, name).map(|(_, _, ps)| ps).unwrap_or_default(); + let declared = env + .applied(&mut self.ctx, name) + .map(|(_, _, ps)| ps) + .unwrap_or_default(); env.remove(name); let mut scheme = self.generalize_with_obligations(env, &fun_ty); // Explicit binders are quantified even when the signature never uses @@ -1170,8 +1180,34 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker checker.collect(program, &mut env); checker.check(program, &mut env); checker.resolve_deferred_arithmetic(); + loop { + let instances = effect_instances(&mut checker); + let errors = crate::effect_rows::check(program, &instances, exports); + if !refine_handler_arguments(&mut checker, &instances) { + checker.errors.extend(errors); + break; + } + } checker.validate_builtin_uses(); checker.validate_discards(); + checker.errors.extend(crate::init_order::check(program)); + checker +} + +/// Publish the current inference solution for the closed-program effect proof. +fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { + let concrete_arguments = checker + .perform_tys + .clone() + .into_iter() + .map(|(_, _, args)| { + args.iter() + .map(|arg| checker.ctx.apply(arg)) + .collect::>() + }) + .filter(|args| args.iter().all(type_is_resolved)) + .map(|args| args.iter().map(ToString::to_string).collect()) + .collect(); let perform_tys = checker.perform_tys.clone(); let perform_actual_tys = checker.perform_actual_tys.clone(); let handler_tys = checker.handler_tys.clone(); @@ -1213,7 +1249,7 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker let _ = performs.insert(key, candidates); } } - let instances = crate::effect_rows::Instances { + crate::effect_rows::Instances { performs, handlers: dedupe_sites(handler_tys.into_iter().map(|(position, arguments, _)| { ( @@ -1224,12 +1260,47 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker .collect(), ) })), - }; - checker - .errors - .extend(crate::effect_rows::check(program, &instances, exports)); - checker.errors.extend(crate::init_order::check(program)); - checker + + concrete_arguments, + ..Default::default() + } +} + +/// A handler whose arms leave its binder open learns that binder from the +/// operations its body requires, including requirements behind function calls. +/// Only one concrete candidate may refine it; incompatible instantiations stay +/// distinct and the ordinary discharge proof rejects the remaining operation. +fn refine_handler_arguments( + checker: &mut Checker, + instances: &crate::effect_rows::Instances, +) -> bool { + let before = checker.ctx.bound_count(); + let candidates = instances.handler_inference.borrow(); + for (position, arguments, _) in checker.handler_tys.clone() { + if arguments + .iter() + .all(|ty| type_is_resolved(&checker.ctx.apply(ty))) + { + continue; + } + let Some(choices) = candidates.get(&(position.line, position.column)) else { + continue; + }; + if choices.len() != 1 { + continue; + } + let Some(choice) = choices.first() else { + continue; + }; + if arguments.len() != choice.len() { + continue; + } + for (argument, concrete) in arguments.iter().zip(choice) { + let ty = type_name_to_type(concrete, &HashMap::new()); + checker.push_unify(argument, &ty); + } + } + checker.ctx.bound_count() != before } /// The code generator's erased view assigns every declared generic parameter diff --git a/crates/osprey-types/src/ctx.rs b/crates/osprey-types/src/ctx.rs index 8edcc175..47493461 100644 --- a/crates/osprey-types/src/ctx.rs +++ b/crates/osprey-types/src/ctx.rs @@ -39,16 +39,37 @@ impl InferCtx { } /// Register a record's generic field template [TYPE-GENERICS-DECL]. - pub(crate) fn set_record(&mut self, name: String, params: Vec, fields: Vec<(String, String)>) { + pub(crate) fn set_record( + &mut self, + name: String, + params: Vec, + fields: Vec<(String, String)>, + ) { let _ = self.records.insert(name, (params, fields)); } /// Resolve a nominal record application to its instantiated fields. - pub(crate) fn record_fields(&self, name: &str, args: &[Type]) -> Option> { + pub(crate) fn record_fields( + &self, + name: &str, + args: &[Type], + ) -> Option> { let (params, fields) = self.records.get(name)?; - if params.len() != args.len() { return None; } + if params.len() != args.len() { + return None; + } let binder = params.iter().cloned().zip(args.iter().cloned()).collect(); - Some(fields.iter().map(|(field, ty)| (field.clone(), crate::convert::type_name_to_type(ty, &binder))).collect()) + Some( + fields + .iter() + .map(|(field, ty)| { + ( + field.clone(), + crate::convert::type_name_to_type(ty, &binder), + ) + }) + .collect(), + ) } /// Allocate a fresh, unbound type variable. diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index c7b2affa..c1d5c58e 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -13,8 +13,11 @@ use osprey_ast::{ Expr, FieldAssignment, HandlerArm, InterpolatedPart, ModuleItem, NamedArgument, Pattern, Position, Program, Stmt, }; +use std::cell::RefCell; use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; +type HandlerCandidates = HashMap<(u32, u32), BTreeSet>>; + #[derive(Default)] pub(crate) struct Instances { /// A source position can identify more than one interpolation fragment. @@ -22,6 +25,11 @@ pub(crate) struct Instances { /// final fragment overwrite the others. pub(crate) performs: HashMap<(u32, u32), Vec>>, pub(crate) handlers: HashMap<(u32, u32), Vec>, + /// Fully resolved operation arguments available to refine a handler. + pub(crate) concrete_arguments: HashSet>, + /// Candidate instantiations required by each handler's body after calls + /// and callbacks have propagated through the closed-program summary. + pub(crate) handler_inference: RefCell, } #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] @@ -646,7 +654,16 @@ impl Analyzer<'_> { &self.instances.handlers, "handler", ); - let mut out = self.expression(body, scope, env).without_operations( + let body_summary = self.expression(body, scope, env); + if let Some(position) = position { + let candidates = body_summary.required.iter().filter(|requirement| { + requirement.effect == *effect && handled.contains(&requirement.operation) + && self.instances.concrete_arguments.contains(&requirement.arguments) + }).map(|requirement| requirement.arguments.clone()); + self.instances.handler_inference.borrow_mut() + .entry((position.line, position.column)).or_default().extend(candidates); + } + let mut out = body_summary.without_operations( effect, &effect_arguments, &handled, @@ -2584,7 +2601,10 @@ fn walk_children<'a>(expression: &'a Expr, mut visit: impl FnMut(&'a Expr)) { visit(left); visit(right); } - Expr::TypeApply { function: operand, .. } | Expr::Unary { operand, .. } + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } | Expr::FieldAccess { target: operand, .. } diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index aba81407..3b9cfbb2 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -67,14 +67,21 @@ impl TypeEnv { } /// Instantiate the signature and its declared binders with one substitution. - pub(crate) fn applied(&self, ctx: &mut InferCtx, name: &str) - -> Option { + pub(crate) fn applied(&self, ctx: &mut InferCtx, name: &str) -> Option { let scheme = self.get(name)?; let map = scheme.vars.iter().map(|v| (*v, ctx.fresh())).collect(); - let params = self.type_params.get(name).into_iter().flatten() - .map(|ty| subst_vars(&ctx.apply(ty), &map)).collect(); - let obligations = scheme.obligations.iter() - .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))).collect(); + let params = self + .type_params + .get(name) + .into_iter() + .flatten() + .map(|ty| subst_vars(&ctx.apply(ty), &map)) + .collect(); + let obligations = scheme + .obligations + .iter() + .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))) + .collect(); Some((subst_vars(&scheme.ty, &map), obligations, params)) } diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index afc6a0f1..57b94486 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -49,7 +49,8 @@ impl Checker { if let InterpolatedPart::Expr(inner) = p { // Interpolation preserves a Result as its complete // Success/Error rendering; it never extracts a payload. - let _ = self.infer_expr(inner, env); + let ty = self.infer_expr(inner, env); + self.builtin_uses.push(("interpolation".to_owned(), ty)); } } Type::string() @@ -86,7 +87,14 @@ impl Checker { self.infer_negation(&t) } } - Expr::TypeApply { function, type_args, position } => self.infer_type_application(function, type_args, *position, env).1, + Expr::TypeApply { + function, + type_args, + position, + } => { + self.infer_type_application(function, type_args, *position, env) + .1 + } Expr::Call { function, arguments, @@ -196,7 +204,11 @@ impl Checker { } } if let Type::Con { name, args } = other { - if let Some(ty) = self.ctx.record_fields(name, args).and_then(|fields| fields.get(field).cloned()) { + if let Some(ty) = self + .ctx + .record_fields(name, args) + .and_then(|fields| fields.get(field).cloned()) + { return ty; } } @@ -555,7 +567,11 @@ impl Checker { fn infer_callee(&mut self, function: &Expr, env: &TypeEnv) -> (Option, Type) { match function { - Expr::TypeApply { function, type_args, position } => self.infer_type_application(function, type_args, *position, env), + Expr::TypeApply { + function, + type_args, + position, + } => self.infer_type_application(function, type_args, *position, env), Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident(name, env)), Expr::Path(path) => { let name = path.to_string(); @@ -567,13 +583,19 @@ impl Checker { } /// Pin declared binders in this call's fresh instantiation [TYPE-GENERICS-APPLY]. - fn infer_type_application(&mut self, function: &Expr, type_args: &[osprey_ast::TypeExpr], position: Option, env: &TypeEnv) - -> (Option, Type) { + fn infer_type_application( + &mut self, + function: &Expr, + type_args: &[osprey_ast::TypeExpr], + position: Option, + env: &TypeEnv, + ) -> (Option, Type) { let name = match function { Expr::Identifier(name) => name.clone(), Expr::Path(path) => path.to_string(), _ => { - self.errors.push(TypeError::new("type arguments require a named function")); + self.errors + .push(TypeError::new("type arguments require a named function")); return (None, self.infer_expr(function, env)); } }; @@ -585,14 +607,62 @@ impl Checker { let binder = self.current_fn_typarams.clone(); for (param, arg) in params.iter().zip(type_args) { let written = crate::convert::type_expr_to_type(arg, &binder); + self.validate_type_argument(&written, position); self.push_unify(param, &written); } } else { - self.errors.push(TypeError::new(format!("function `{name}` takes {} type argument(s), got {}", params.len(), type_args.len())).with_pos(position)); + self.errors.push( + TypeError::new(format!( + "function `{name}` takes {} type argument(s), got {}", + params.len(), + type_args.len() + )) + .with_pos(position), + ); } (Some(name), ty) } + /// Written arguments name declared types or an enclosing binder, never a + /// new nominal type inferred from a misspelled name [TYPE-GENERICS-APPLY]. + fn validate_type_argument(&mut self, ty: &Type, position: Option) { + match ty { + Type::Con { name, args } => { + let primitive = matches!( + name.as_str(), + names::INT + | names::FLOAT + | names::BOOL + | names::STRING + | names::UNIT + | names::ANY + | names::PTR + | names::MATH_ERROR + | names::CHANNEL + | names::ITERATOR + | names::GPU_BUFFER + ); + if !primitive + && self.ctx.variance_of(name).is_none() + && !self.ctors.values().any(|ctor| ctor.owner == *name) + { + self.errors + .push(TypeError::new(format!("unknown type `{name}`")).with_pos(position)); + } + for arg in args { + self.validate_type_argument(arg, position); + } + } + Type::Fun { params, ret } => { + for param in params { + self.validate_type_argument(param, position); + } + self.validate_type_argument(ret, position); + } + _ => {} + } + } + fn infer_method_call( &mut self, target: &Expr, diff --git a/crates/osprey-types/src/unify.rs b/crates/osprey-types/src/unify.rs index 958c3cb8..c5de7ba7 100644 --- a/crates/osprey-types/src/unify.rs +++ b/crates/osprey-types/src/unify.rs @@ -58,14 +58,23 @@ pub fn unify(ctx: &mut InferCtx, a: &Type, b: &Type) -> Result<(), TypeError> { Ok(()) } - (Type::Con { name, args }, Type::Record { name: actual, fields }) - | (Type::Record { name: actual, fields }, Type::Con { name, args }) - if name == actual => { - match ctx.record_fields(name, args) { - Some(declared) => unify_record(ctx, &declared, fields, &a, &b), - None => Err(TypeError::mismatch(&a, &b)), - } - } + ( + Type::Con { name, args }, + Type::Record { + name: actual, + fields, + }, + ) + | ( + Type::Record { + name: actual, + fields, + }, + Type::Con { name, args }, + ) if name == actual => match ctx.record_fields(name, args) { + Some(declared) => unify_record(ctx, &declared, fields, &a, &b), + None => Err(TypeError::mismatch(&a, &b)), + }, ( Type::Union { diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index 2db282c7..04fd6291 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -229,6 +229,15 @@ executable assertions. Each is recorded with the evidence that settles it. angles are legal on a ROW (`!Stash`), and the written mention belongs to `static effect`, whose identity IS the instantiation. + **Replacement diagnostic** (same rule, true reason — the fixture golden is + updated in the same commit that emits it): + + > ``perform Signal`` names an instantiation of dynamic effect + > ``Signal``; a written instantiation is the identity of a ``static effect``, + > while a dynamic effect takes its instantiation from inference + > (docs/plans/0024-staged-effects.md). Declare ``static effect Signal``, or + > write ``perform Signal`` and let inference instantiate it + 4. **Spec 0017 writes `handle … do`; the language accepts `in`.** Intended: the Default flavor is moving to `do` ([plan 0027](0027-arithmetic-effects.md) phase 0). `the_spec_writes_a_handled_body_after_do` is a deliberate red pin diff --git a/tree-sitter-osprey/grammar.js b/tree-sitter-osprey/grammar.js index f2db83fc..ddf8d49f 100644 --- a/tree-sitter-osprey/grammar.js +++ b/tree-sitter-osprey/grammar.js @@ -439,7 +439,7 @@ module.exports = grammar({ // and `Signal` are different effects to a row, so they are different // effects to a handler. Implements [STAGE-SIGNALS-EXACT]. handler_expression: ($) => - prec.right(seq('handle', optional(field('stage', $.static_stage)), field('effect', choice($.qualified_path, $.identifier)), optional(field('instantiation', $.type_arguments)), repeat1($.handler_arm), 'in', field('body', $.expression))), + prec.right(seq('handle', optional(field('stage', $.static_stage)), field('effect', choice($.qualified_path, $.identifier)), optional(field('instantiation', $.type_arguments)), repeat1($.handler_arm), choice('in', 'do'), field('body', $.expression))), handler_arm: ($) => seq(field('operation', $.identifier), optional($.handler_params), '=>', field('body', $.expression)), handler_params: ($) => repeat1($.identifier), @@ -587,7 +587,9 @@ module.exports = grammar({ type_constructor: ($) => prec.dynamic(1, seq(field('name', choice($.qualified_path, $.identifier)), optional($.type_arguments), '{', $.field_assignments, '}')), type_arguments: ($) => seq(token.immediate('<'), $.type_list, '>'), - _call_type_arguments: ($) => seq(token.immediate('<'), $.type_list, '>'), + _call_type_arguments: ($) => seq(token.immediate('<'), alias($._call_type_list, $.type_list), '>'), + // Keep misplaced declaration markers visible for a precise diagnostic. + _call_type_list: ($) => sep1(',', seq(optional(field('variance', choice('in', 'out'))), $._type)), update_expression: ($) => prec.dynamic(0, seq(field('record', $.identifier), '{', $.field_assignments, '}')), diff --git a/tree-sitter-osprey/src/grammar.json b/tree-sitter-osprey/src/grammar.json index 6283c79c..869ef67f 100644 --- a/tree-sitter-osprey/src/grammar.json +++ b/tree-sitter-osprey/src/grammar.json @@ -2029,8 +2029,17 @@ } }, { - "type": "STRING", - "value": "in" + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "in" + }, + { + "type": "STRING", + "value": "do" + } + ] }, { "type": "FIELD", @@ -3442,8 +3451,13 @@ } }, { - "type": "SYMBOL", - "name": "type_list" + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_call_type_list" + }, + "named": true, + "value": "type_list" }, { "type": "STRING", @@ -3451,6 +3465,91 @@ } ] }, + "_call_type_list": { + "type": "SEQ", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "variance", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "in" + }, + { + "type": "STRING", + "value": "out" + } + ] + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_type" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "variance", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "in" + }, + { + "type": "STRING", + "value": "out" + } + ] + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_type" + } + ] + } + ] + } + } + ] + }, "update_expression": { "type": "PREC_DYNAMIC", "value": 0, diff --git a/tree-sitter-osprey/src/node-types.json b/tree-sitter-osprey/src/node-types.json index d7c31728..2f53840e 100644 --- a/tree-sitter-osprey/src/node-types.json +++ b/tree-sitter-osprey/src/node-types.json @@ -2965,7 +2965,22 @@ { "type": "type_list", "named": true, - "fields": {}, + "fields": { + "variance": { + "multiple": true, + "required": false, + "types": [ + { + "type": "in", + "named": false + }, + { + "type": "out", + "named": false + } + ] + } + }, "children": { "multiple": true, "required": true, @@ -3311,6 +3326,10 @@ "type": "await", "named": false }, + { + "type": "do", + "named": false + }, { "type": "effect", "named": false diff --git a/tree-sitter-osprey/src/parser.c b/tree-sitter-osprey/src/parser.c index bba9b0e9..6792f2a6 100644 --- a/tree-sitter-osprey/src/parser.c +++ b/tree-sitter-osprey/src/parser.c @@ -5,15 +5,15 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 1751 +#define STATE_COUNT 1761 #define LARGE_STATE_COUNT 21 -#define SYMBOL_COUNT 217 +#define SYMBOL_COUNT 220 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 85 +#define TOKEN_COUNT 86 #define EXTERNAL_TOKEN_COUNT 2 #define FIELD_COUNT 49 #define MAX_ALIAS_SEQUENCE_LENGTH 14 -#define PRODUCTION_ID_COUNT 193 +#define PRODUCTION_ID_COUNT 198 enum ts_symbol_identifiers { sym_identifier = 1, @@ -58,180 +58,183 @@ enum ts_symbol_identifiers { anon_sym_if = 40, anon_sym_else = 41, anon_sym_handle = 42, - anon_sym_kernel = 43, - anon_sym_select = 44, - anon_sym_QMARK = 45, - anon_sym_PIPE_PIPE = 46, - anon_sym_AMP_AMP = 47, - anon_sym_EQ_EQ = 48, - anon_sym_BANG_EQ = 49, - anon_sym_LT_EQ = 50, - anon_sym_GT_EQ = 51, - anon_sym_PLUS = 52, - anon_sym_DASH = 53, - anon_sym_SLASH = 54, - anon_sym_PERCENT = 55, - anon_sym_await = 56, - anon_sym_PIPE_GT = 57, - anon_sym_LPAREN2 = 58, - anon_sym_LBRACK2 = 59, - anon_sym_spawn = 60, - anon_sym_yield = 61, - anon_sym_send = 62, - anon_sym_recv = 63, - anon_sym_perform = 64, - anon_sym_resume = 65, - anon_sym_LT2 = 66, - anon_sym_DOT_DOT = 67, - anon_sym_DOT_DOT_DOT = 68, - anon_sym_state = 69, - anon_sym_module = 70, - anon_sym_extra = 71, - anon_sym_export = 72, - anon_sym_opaque = 73, - anon_sym_signature = 74, - anon_sym_true = 75, - anon_sym_false = 76, - sym_float = 77, - sym_integer = 78, - sym_string = 79, - sym_interpolated_string = 80, - sym__doc_comment_line = 81, - sym_line_comment = 82, - sym__call_open_gap = 83, - sym__statement_break = 84, - sym_source_file = 85, - sym_statement = 86, - sym_import_statement = 87, - sym_legacy_import_path = 88, - sym_import_target = 89, - sym_import_tail = 90, - sym_import_member_list = 91, - sym_import_member = 92, - sym_namespace_name = 93, - sym_namespace_declaration = 94, - sym_namespace_body = 95, - sym_let_declaration = 96, - sym_assignment = 97, - sym_function_declaration = 98, - sym_extern_declaration = 99, - sym_extern_parameter_list = 100, - sym_extern_parameter = 101, - sym_parameter_list = 102, - sym_parameter = 103, - sym_type_declaration = 104, - sym_type_parameter_list = 105, - sym_type_parameter = 106, - sym_union_type = 107, - sym_type_alias = 108, - sym_variant = 109, - sym_positional_payload = 110, - sym_record_type = 111, - sym_field_declarations = 112, - sym_field_declaration = 113, - sym_type_validation = 114, - sym_effect_declaration = 115, - sym_multiplicity = 116, - sym_operation_declaration = 117, - sym_effect_set = 118, - sym_effect_list = 119, - sym_effect_ref = 120, - sym__type = 121, - sym_function_type = 122, - sym_generic_type = 123, - sym_array_type = 124, - sym_type_identifier = 125, - sym_type_list = 126, - sym_expression_statement = 127, - sym_expression = 128, - sym_match_expression = 129, - sym_match_arm = 130, - sym_if_expression = 131, - sym_handler_expression = 132, - sym_handler_arm = 133, - sym_handler_params = 134, - sym_kernel_expression = 135, - sym_kernel_arm = 136, - sym_select_expression = 137, - sym_select_arm = 138, - sym_ternary_expression = 139, - sym_binary_expression = 140, - sym_unary_expression = 141, - sym_pipe_expression = 142, - sym_call_expression = 143, - sym_argument_list = 144, - sym_named_argument_list = 145, - sym_named_argument = 146, - sym_primary_expression = 147, - sym_spawn_expression = 148, - sym_yield_expression = 149, - sym_await_call = 150, - sym_send_call = 151, - sym_recv_call = 152, - sym_perform_expression = 153, - sym_resume_expression = 154, - sym_type_constructor = 155, - sym_type_arguments = 156, - sym__call_type_arguments = 157, - sym_update_expression = 158, - sym_field_assignments = 159, - sym_field_assignment = 160, - sym_block = 161, - sym_object_literal = 162, - sym_lambda_expression = 163, - sym_literal = 164, - sym_list_literal = 165, - sym_map_literal = 166, - sym_map_entry = 167, - sym_pattern = 168, - sym_structural_pattern = 169, - sym_tuple_pattern = 170, - sym_list_pattern = 171, - sym_field_pattern = 172, - sym_module_declaration = 173, - sym_signature_ascription = 174, - sym_module_item = 175, - sym_export_declaration = 176, - sym__module_declaration = 177, - sym_signature_declaration = 178, - sym_signature_item = 179, - sym_signature_value = 180, - sym_signature_function = 181, - sym_signature_type = 182, - sym_signature_module = 183, - sym_qualified_path = 184, - sym_symbol_path = 185, - sym_boolean = 186, - sym_doc_comment = 187, - aux_sym_source_file_repeat1 = 188, - aux_sym_legacy_import_path_repeat1 = 189, - aux_sym_import_target_repeat1 = 190, - aux_sym_import_member_list_repeat1 = 191, - aux_sym_extern_parameter_list_repeat1 = 192, - aux_sym_parameter_list_repeat1 = 193, - aux_sym_type_parameter_list_repeat1 = 194, - aux_sym_union_type_repeat1 = 195, - aux_sym_positional_payload_repeat1 = 196, - aux_sym_field_declarations_repeat1 = 197, - aux_sym_effect_declaration_repeat1 = 198, - aux_sym_effect_list_repeat1 = 199, - aux_sym_match_expression_repeat1 = 200, - aux_sym_handler_expression_repeat1 = 201, - aux_sym_handler_params_repeat1 = 202, - aux_sym_kernel_expression_repeat1 = 203, - aux_sym_select_expression_repeat1 = 204, - aux_sym_argument_list_repeat1 = 205, - aux_sym_named_argument_list_repeat1 = 206, - aux_sym_field_assignments_repeat1 = 207, - aux_sym_map_literal_repeat1 = 208, - aux_sym_pattern_repeat1 = 209, - aux_sym_tuple_pattern_repeat1 = 210, - aux_sym_list_pattern_repeat1 = 211, - aux_sym_field_pattern_repeat1 = 212, - aux_sym_module_declaration_repeat1 = 213, - aux_sym_signature_declaration_repeat1 = 214, - aux_sym_qualified_path_repeat1 = 215, - aux_sym_doc_comment_repeat1 = 216, + anon_sym_do = 43, + anon_sym_kernel = 44, + anon_sym_select = 45, + anon_sym_QMARK = 46, + anon_sym_PIPE_PIPE = 47, + anon_sym_AMP_AMP = 48, + anon_sym_EQ_EQ = 49, + anon_sym_BANG_EQ = 50, + anon_sym_LT_EQ = 51, + anon_sym_GT_EQ = 52, + anon_sym_PLUS = 53, + anon_sym_DASH = 54, + anon_sym_SLASH = 55, + anon_sym_PERCENT = 56, + anon_sym_await = 57, + anon_sym_PIPE_GT = 58, + anon_sym_LPAREN2 = 59, + anon_sym_LBRACK2 = 60, + anon_sym_spawn = 61, + anon_sym_yield = 62, + anon_sym_send = 63, + anon_sym_recv = 64, + anon_sym_perform = 65, + anon_sym_resume = 66, + anon_sym_LT2 = 67, + anon_sym_DOT_DOT = 68, + anon_sym_DOT_DOT_DOT = 69, + anon_sym_state = 70, + anon_sym_module = 71, + anon_sym_extra = 72, + anon_sym_export = 73, + anon_sym_opaque = 74, + anon_sym_signature = 75, + anon_sym_true = 76, + anon_sym_false = 77, + sym_float = 78, + sym_integer = 79, + sym_string = 80, + sym_interpolated_string = 81, + sym__doc_comment_line = 82, + sym_line_comment = 83, + sym__call_open_gap = 84, + sym__statement_break = 85, + sym_source_file = 86, + sym_statement = 87, + sym_import_statement = 88, + sym_legacy_import_path = 89, + sym_import_target = 90, + sym_import_tail = 91, + sym_import_member_list = 92, + sym_import_member = 93, + sym_namespace_name = 94, + sym_namespace_declaration = 95, + sym_namespace_body = 96, + sym_let_declaration = 97, + sym_assignment = 98, + sym_function_declaration = 99, + sym_extern_declaration = 100, + sym_extern_parameter_list = 101, + sym_extern_parameter = 102, + sym_parameter_list = 103, + sym_parameter = 104, + sym_type_declaration = 105, + sym_type_parameter_list = 106, + sym_type_parameter = 107, + sym_union_type = 108, + sym_type_alias = 109, + sym_variant = 110, + sym_positional_payload = 111, + sym_record_type = 112, + sym_field_declarations = 113, + sym_field_declaration = 114, + sym_type_validation = 115, + sym_effect_declaration = 116, + sym_multiplicity = 117, + sym_operation_declaration = 118, + sym_effect_set = 119, + sym_effect_list = 120, + sym_effect_ref = 121, + sym__type = 122, + sym_function_type = 123, + sym_generic_type = 124, + sym_array_type = 125, + sym_type_identifier = 126, + sym_type_list = 127, + sym_expression_statement = 128, + sym_expression = 129, + sym_match_expression = 130, + sym_match_arm = 131, + sym_if_expression = 132, + sym_handler_expression = 133, + sym_handler_arm = 134, + sym_handler_params = 135, + sym_kernel_expression = 136, + sym_kernel_arm = 137, + sym_select_expression = 138, + sym_select_arm = 139, + sym_ternary_expression = 140, + sym_binary_expression = 141, + sym_unary_expression = 142, + sym_pipe_expression = 143, + sym_call_expression = 144, + sym_argument_list = 145, + sym_named_argument_list = 146, + sym_named_argument = 147, + sym_primary_expression = 148, + sym_spawn_expression = 149, + sym_yield_expression = 150, + sym_await_call = 151, + sym_send_call = 152, + sym_recv_call = 153, + sym_perform_expression = 154, + sym_resume_expression = 155, + sym_type_constructor = 156, + sym_type_arguments = 157, + sym__call_type_arguments = 158, + sym__call_type_list = 159, + sym_update_expression = 160, + sym_field_assignments = 161, + sym_field_assignment = 162, + sym_block = 163, + sym_object_literal = 164, + sym_lambda_expression = 165, + sym_literal = 166, + sym_list_literal = 167, + sym_map_literal = 168, + sym_map_entry = 169, + sym_pattern = 170, + sym_structural_pattern = 171, + sym_tuple_pattern = 172, + sym_list_pattern = 173, + sym_field_pattern = 174, + sym_module_declaration = 175, + sym_signature_ascription = 176, + sym_module_item = 177, + sym_export_declaration = 178, + sym__module_declaration = 179, + sym_signature_declaration = 180, + sym_signature_item = 181, + sym_signature_value = 182, + sym_signature_function = 183, + sym_signature_type = 184, + sym_signature_module = 185, + sym_qualified_path = 186, + sym_symbol_path = 187, + sym_boolean = 188, + sym_doc_comment = 189, + aux_sym_source_file_repeat1 = 190, + aux_sym_legacy_import_path_repeat1 = 191, + aux_sym_import_target_repeat1 = 192, + aux_sym_import_member_list_repeat1 = 193, + aux_sym_extern_parameter_list_repeat1 = 194, + aux_sym_parameter_list_repeat1 = 195, + aux_sym_type_parameter_list_repeat1 = 196, + aux_sym_union_type_repeat1 = 197, + aux_sym_positional_payload_repeat1 = 198, + aux_sym_field_declarations_repeat1 = 199, + aux_sym_effect_declaration_repeat1 = 200, + aux_sym_effect_list_repeat1 = 201, + aux_sym_match_expression_repeat1 = 202, + aux_sym_handler_expression_repeat1 = 203, + aux_sym_handler_params_repeat1 = 204, + aux_sym_kernel_expression_repeat1 = 205, + aux_sym_select_expression_repeat1 = 206, + aux_sym_argument_list_repeat1 = 207, + aux_sym_named_argument_list_repeat1 = 208, + aux_sym__call_type_list_repeat1 = 209, + aux_sym_field_assignments_repeat1 = 210, + aux_sym_map_literal_repeat1 = 211, + aux_sym_pattern_repeat1 = 212, + aux_sym_tuple_pattern_repeat1 = 213, + aux_sym_list_pattern_repeat1 = 214, + aux_sym_field_pattern_repeat1 = 215, + aux_sym_module_declaration_repeat1 = 216, + aux_sym_signature_declaration_repeat1 = 217, + aux_sym_qualified_path_repeat1 = 218, + aux_sym_doc_comment_repeat1 = 219, }; static const char * const ts_symbol_names[] = { @@ -278,6 +281,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_if] = "if", [anon_sym_else] = "else", [anon_sym_handle] = "handle", + [anon_sym_do] = "do", [anon_sym_kernel] = "kernel", [anon_sym_select] = "select", [anon_sym_QMARK] = "\?", @@ -393,6 +397,7 @@ static const char * const ts_symbol_names[] = { [sym_type_constructor] = "type_constructor", [sym_type_arguments] = "type_arguments", [sym__call_type_arguments] = "type_arguments", + [sym__call_type_list] = "type_list", [sym_update_expression] = "update_expression", [sym_field_assignments] = "field_assignments", [sym_field_assignment] = "field_assignment", @@ -442,6 +447,7 @@ static const char * const ts_symbol_names[] = { [aux_sym_select_expression_repeat1] = "select_expression_repeat1", [aux_sym_argument_list_repeat1] = "argument_list_repeat1", [aux_sym_named_argument_list_repeat1] = "named_argument_list_repeat1", + [aux_sym__call_type_list_repeat1] = "_call_type_list_repeat1", [aux_sym_field_assignments_repeat1] = "field_assignments_repeat1", [aux_sym_map_literal_repeat1] = "map_literal_repeat1", [aux_sym_pattern_repeat1] = "pattern_repeat1", @@ -498,6 +504,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_if] = anon_sym_if, [anon_sym_else] = anon_sym_else, [anon_sym_handle] = anon_sym_handle, + [anon_sym_do] = anon_sym_do, [anon_sym_kernel] = anon_sym_kernel, [anon_sym_select] = anon_sym_select, [anon_sym_QMARK] = anon_sym_QMARK, @@ -613,6 +620,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_type_constructor] = sym_type_constructor, [sym_type_arguments] = sym_type_arguments, [sym__call_type_arguments] = sym_type_arguments, + [sym__call_type_list] = sym_type_list, [sym_update_expression] = sym_update_expression, [sym_field_assignments] = sym_field_assignments, [sym_field_assignment] = sym_field_assignment, @@ -662,6 +670,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_select_expression_repeat1] = aux_sym_select_expression_repeat1, [aux_sym_argument_list_repeat1] = aux_sym_argument_list_repeat1, [aux_sym_named_argument_list_repeat1] = aux_sym_named_argument_list_repeat1, + [aux_sym__call_type_list_repeat1] = aux_sym__call_type_list_repeat1, [aux_sym_field_assignments_repeat1] = aux_sym_field_assignments_repeat1, [aux_sym_map_literal_repeat1] = aux_sym_map_literal_repeat1, [aux_sym_pattern_repeat1] = aux_sym_pattern_repeat1, @@ -847,6 +856,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_do] = { + .visible = true, + .named = false, + }, [anon_sym_kernel] = { .visible = true, .named = false, @@ -1307,6 +1320,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym__call_type_list] = { + .visible = true, + .named = true, + }, [sym_update_expression] = { .visible = true, .named = true, @@ -1503,6 +1520,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, + [aux_sym__call_type_list_repeat1] = { + .visible = false, + .named = false, + }, [aux_sym_field_assignments_repeat1] = { .visible = false, .named = false, @@ -1683,166 +1704,171 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [30] = {.index = 48, .length = 1}, [31] = {.index = 49, .length = 2}, [32] = {.index = 51, .length = 2}, - [33] = {.index = 53, .length = 2}, - [34] = {.index = 55, .length = 2}, - [35] = {.index = 57, .length = 3}, - [36] = {.index = 60, .length = 1}, - [37] = {.index = 61, .length = 2}, - [38] = {.index = 63, .length = 2}, - [39] = {.index = 65, .length = 1}, - [40] = {.index = 66, .length = 2}, - [41] = {.index = 68, .length = 2}, - [42] = {.index = 70, .length = 2}, - [43] = {.index = 72, .length = 3}, - [44] = {.index = 75, .length = 1}, - [45] = {.index = 76, .length = 2}, - [46] = {.index = 78, .length = 3}, - [47] = {.index = 81, .length = 1}, - [48] = {.index = 82, .length = 3}, - [49] = {.index = 85, .length = 3}, - [50] = {.index = 88, .length = 3}, - [51] = {.index = 91, .length = 2}, - [52] = {.index = 93, .length = 2}, - [53] = {.index = 95, .length = 4}, - [54] = {.index = 99, .length = 1}, - [55] = {.index = 100, .length = 2}, - [56] = {.index = 102, .length = 3}, - [57] = {.index = 105, .length = 3}, - [58] = {.index = 108, .length = 2}, - [59] = {.index = 35, .length = 2}, - [60] = {.index = 110, .length = 3}, - [61] = {.index = 113, .length = 2}, - [62] = {.index = 115, .length = 3}, - [63] = {.index = 118, .length = 3}, - [64] = {.index = 121, .length = 2}, - [65] = {.index = 123, .length = 2}, - [66] = {.index = 125, .length = 2}, - [67] = {.index = 127, .length = 4}, - [68] = {.index = 131, .length = 2}, - [69] = {.index = 133, .length = 1}, - [70] = {.index = 134, .length = 2}, - [71] = {.index = 136, .length = 2}, - [72] = {.index = 138, .length = 2}, - [73] = {.index = 140, .length = 2}, - [74] = {.index = 142, .length = 1}, - [75] = {.index = 143, .length = 2}, - [76] = {.index = 145, .length = 3}, - [77] = {.index = 148, .length = 3}, - [78] = {.index = 151, .length = 2}, - [79] = {.index = 153, .length = 1}, - [80] = {.index = 154, .length = 3}, - [81] = {.index = 157, .length = 3}, - [82] = {.index = 160, .length = 3}, - [83] = {.index = 163, .length = 4}, - [84] = {.index = 167, .length = 2}, - [85] = {.index = 169, .length = 2}, - [86] = {.index = 171, .length = 3}, - [87] = {.index = 174, .length = 3}, - [88] = {.index = 174, .length = 3}, - [89] = {.index = 177, .length = 3}, - [90] = {.index = 177, .length = 3}, - [91] = {.index = 180, .length = 2}, - [92] = {.index = 180, .length = 2}, - [93] = {.index = 182, .length = 2}, + [33] = {.index = 53, .length = 1}, + [34] = {.index = 54, .length = 1}, + [35] = {.index = 55, .length = 2}, + [36] = {.index = 57, .length = 2}, + [37] = {.index = 59, .length = 3}, + [38] = {.index = 62, .length = 1}, + [39] = {.index = 63, .length = 2}, + [40] = {.index = 65, .length = 2}, + [41] = {.index = 67, .length = 1}, + [42] = {.index = 68, .length = 2}, + [43] = {.index = 70, .length = 2}, + [44] = {.index = 72, .length = 2}, + [45] = {.index = 74, .length = 3}, + [46] = {.index = 77, .length = 1}, + [47] = {.index = 78, .length = 2}, + [48] = {.index = 80, .length = 3}, + [49] = {.index = 83, .length = 1}, + [50] = {.index = 84, .length = 3}, + [51] = {.index = 87, .length = 3}, + [52] = {.index = 90, .length = 2}, + [53] = {.index = 92, .length = 2}, + [54] = {.index = 94, .length = 3}, + [55] = {.index = 97, .length = 2}, + [56] = {.index = 99, .length = 2}, + [57] = {.index = 101, .length = 4}, + [58] = {.index = 105, .length = 1}, + [59] = {.index = 106, .length = 2}, + [60] = {.index = 108, .length = 3}, + [61] = {.index = 111, .length = 3}, + [62] = {.index = 114, .length = 2}, + [63] = {.index = 35, .length = 2}, + [64] = {.index = 116, .length = 3}, + [65] = {.index = 119, .length = 2}, + [66] = {.index = 121, .length = 3}, + [67] = {.index = 124, .length = 3}, + [68] = {.index = 127, .length = 2}, + [69] = {.index = 129, .length = 2}, + [70] = {.index = 131, .length = 2}, + [71] = {.index = 133, .length = 4}, + [72] = {.index = 137, .length = 2}, + [73] = {.index = 139, .length = 1}, + [74] = {.index = 140, .length = 2}, + [75] = {.index = 142, .length = 2}, + [76] = {.index = 144, .length = 2}, + [77] = {.index = 146, .length = 1}, + [78] = {.index = 147, .length = 2}, + [79] = {.index = 149, .length = 1}, + [80] = {.index = 150, .length = 2}, + [81] = {.index = 152, .length = 3}, + [82] = {.index = 155, .length = 3}, + [83] = {.index = 158, .length = 2}, + [84] = {.index = 160, .length = 1}, + [85] = {.index = 161, .length = 3}, + [86] = {.index = 164, .length = 3}, + [87] = {.index = 167, .length = 3}, + [88] = {.index = 170, .length = 4}, + [89] = {.index = 174, .length = 2}, + [90] = {.index = 176, .length = 2}, + [91] = {.index = 178, .length = 3}, + [92] = {.index = 181, .length = 3}, + [93] = {.index = 181, .length = 3}, [94] = {.index = 184, .length = 3}, - [95] = {.index = 187, .length = 4}, - [96] = {.index = 191, .length = 3}, - [97] = {.index = 194, .length = 2}, - [98] = {.index = 196, .length = 4}, - [99] = {.index = 200, .length = 2}, - [100] = {.index = 202, .length = 3}, - [101] = {.index = 205, .length = 3}, - [102] = {.index = 208, .length = 2}, - [103] = {.index = 210, .length = 4}, - [104] = {.index = 214, .length = 1}, - [105] = {.index = 215, .length = 3}, - [106] = {.index = 218, .length = 3}, - [107] = {.index = 221, .length = 4}, - [108] = {.index = 225, .length = 4}, - [109] = {.index = 229, .length = 4}, - [110] = {.index = 233, .length = 3}, - [111] = {.index = 236, .length = 3}, - [112] = {.index = 239, .length = 4}, - [113] = {.index = 239, .length = 4}, - [114] = {.index = 243, .length = 3}, - [115] = {.index = 243, .length = 3}, - [116] = {.index = 246, .length = 3}, - [117] = {.index = 246, .length = 3}, - [118] = {.index = 249, .length = 2}, - [119] = {.index = 251, .length = 2}, - [120] = {.index = 253, .length = 2}, - [121] = {.index = 255, .length = 3}, - [122] = {.index = 258, .length = 1}, - [123] = {.index = 259, .length = 3}, - [124] = {.index = 262, .length = 3}, - [125] = {.index = 265, .length = 3}, - [126] = {.index = 268, .length = 4}, - [127] = {.index = 272, .length = 2}, - [128] = {.index = 274, .length = 3}, - [129] = {.index = 277, .length = 2}, - [130] = {.index = 279, .length = 3}, - [131] = {.index = 282, .length = 4}, - [132] = {.index = 286, .length = 4}, - [133] = {.index = 290, .length = 4}, - [134] = {.index = 294, .length = 4}, - [135] = {.index = 298, .length = 5}, - [136] = {.index = 303, .length = 4}, - [137] = {.index = 303, .length = 4}, - [138] = {.index = 307, .length = 3}, - [139] = {.index = 310, .length = 3}, - [140] = {.index = 313, .length = 2}, - [141] = {.index = 315, .length = 3}, - [142] = {.index = 318, .length = 3}, - [143] = {.index = 321, .length = 3}, - [144] = {.index = 324, .length = 3}, - [145] = {.index = 327, .length = 4}, - [146] = {.index = 331, .length = 4}, - [147] = {.index = 335, .length = 4}, - [148] = {.index = 339, .length = 3}, - [149] = {.index = 342, .length = 3}, - [150] = {.index = 345, .length = 4}, - [151] = {.index = 349, .length = 4}, - [152] = {.index = 353, .length = 4}, - [153] = {.index = 357, .length = 5}, - [154] = {.index = 362, .length = 5}, - [155] = {.index = 367, .length = 3}, - [156] = {.index = 370, .length = 3}, - [157] = {.index = 373, .length = 3}, - [158] = {.index = 376, .length = 4}, - [159] = {.index = 380, .length = 4}, - [160] = {.index = 384, .length = 4}, - [161] = {.index = 388, .length = 4}, - [162] = {.index = 392, .length = 5}, - [163] = {.index = 397, .length = 4}, - [164] = {.index = 401, .length = 5}, - [165] = {.index = 406, .length = 5}, - [166] = {.index = 411, .length = 5}, - [167] = {.index = 416, .length = 3}, - [168] = {.index = 419, .length = 3}, - [169] = {.index = 422, .length = 4}, - [170] = {.index = 426, .length = 4}, - [171] = {.index = 430, .length = 4}, - [172] = {.index = 434, .length = 4}, - [173] = {.index = 438, .length = 4}, - [174] = {.index = 442, .length = 5}, - [175] = {.index = 447, .length = 5}, - [176] = {.index = 452, .length = 5}, - [177] = {.index = 457, .length = 5}, - [178] = {.index = 462, .length = 6}, - [179] = {.index = 468, .length = 3}, - [180] = {.index = 471, .length = 4}, - [181] = {.index = 475, .length = 4}, - [182] = {.index = 479, .length = 5}, - [183] = {.index = 484, .length = 5}, - [184] = {.index = 489, .length = 5}, - [185] = {.index = 494, .length = 6}, - [186] = {.index = 500, .length = 4}, - [187] = {.index = 504, .length = 4}, - [188] = {.index = 508, .length = 5}, - [189] = {.index = 513, .length = 5}, - [190] = {.index = 518, .length = 6}, - [191] = {.index = 524, .length = 5}, - [192] = {.index = 529, .length = 6}, + [95] = {.index = 184, .length = 3}, + [96] = {.index = 187, .length = 2}, + [97] = {.index = 187, .length = 2}, + [98] = {.index = 189, .length = 2}, + [99] = {.index = 191, .length = 3}, + [100] = {.index = 194, .length = 4}, + [101] = {.index = 198, .length = 3}, + [102] = {.index = 201, .length = 2}, + [103] = {.index = 203, .length = 4}, + [104] = {.index = 207, .length = 2}, + [105] = {.index = 209, .length = 3}, + [106] = {.index = 212, .length = 3}, + [107] = {.index = 215, .length = 2}, + [108] = {.index = 217, .length = 4}, + [109] = {.index = 221, .length = 1}, + [110] = {.index = 222, .length = 3}, + [111] = {.index = 225, .length = 3}, + [112] = {.index = 228, .length = 4}, + [113] = {.index = 232, .length = 4}, + [114] = {.index = 236, .length = 4}, + [115] = {.index = 240, .length = 3}, + [116] = {.index = 243, .length = 3}, + [117] = {.index = 246, .length = 4}, + [118] = {.index = 246, .length = 4}, + [119] = {.index = 250, .length = 3}, + [120] = {.index = 250, .length = 3}, + [121] = {.index = 253, .length = 3}, + [122] = {.index = 253, .length = 3}, + [123] = {.index = 256, .length = 2}, + [124] = {.index = 258, .length = 2}, + [125] = {.index = 260, .length = 2}, + [126] = {.index = 262, .length = 3}, + [127] = {.index = 265, .length = 1}, + [128] = {.index = 266, .length = 3}, + [129] = {.index = 269, .length = 3}, + [130] = {.index = 272, .length = 3}, + [131] = {.index = 275, .length = 4}, + [132] = {.index = 279, .length = 2}, + [133] = {.index = 281, .length = 3}, + [134] = {.index = 284, .length = 2}, + [135] = {.index = 286, .length = 3}, + [136] = {.index = 289, .length = 4}, + [137] = {.index = 293, .length = 4}, + [138] = {.index = 297, .length = 4}, + [139] = {.index = 301, .length = 4}, + [140] = {.index = 305, .length = 5}, + [141] = {.index = 310, .length = 4}, + [142] = {.index = 310, .length = 4}, + [143] = {.index = 314, .length = 3}, + [144] = {.index = 317, .length = 3}, + [145] = {.index = 320, .length = 2}, + [146] = {.index = 322, .length = 3}, + [147] = {.index = 325, .length = 3}, + [148] = {.index = 328, .length = 3}, + [149] = {.index = 331, .length = 3}, + [150] = {.index = 334, .length = 4}, + [151] = {.index = 338, .length = 4}, + [152] = {.index = 342, .length = 4}, + [153] = {.index = 346, .length = 3}, + [154] = {.index = 349, .length = 3}, + [155] = {.index = 352, .length = 4}, + [156] = {.index = 356, .length = 4}, + [157] = {.index = 360, .length = 4}, + [158] = {.index = 364, .length = 5}, + [159] = {.index = 369, .length = 5}, + [160] = {.index = 374, .length = 3}, + [161] = {.index = 377, .length = 3}, + [162] = {.index = 380, .length = 3}, + [163] = {.index = 383, .length = 4}, + [164] = {.index = 387, .length = 4}, + [165] = {.index = 391, .length = 4}, + [166] = {.index = 395, .length = 4}, + [167] = {.index = 399, .length = 5}, + [168] = {.index = 404, .length = 4}, + [169] = {.index = 408, .length = 5}, + [170] = {.index = 413, .length = 5}, + [171] = {.index = 418, .length = 5}, + [172] = {.index = 423, .length = 3}, + [173] = {.index = 426, .length = 3}, + [174] = {.index = 429, .length = 4}, + [175] = {.index = 433, .length = 4}, + [176] = {.index = 437, .length = 4}, + [177] = {.index = 441, .length = 4}, + [178] = {.index = 445, .length = 4}, + [179] = {.index = 449, .length = 5}, + [180] = {.index = 454, .length = 5}, + [181] = {.index = 459, .length = 5}, + [182] = {.index = 464, .length = 5}, + [183] = {.index = 469, .length = 6}, + [184] = {.index = 475, .length = 3}, + [185] = {.index = 478, .length = 4}, + [186] = {.index = 482, .length = 4}, + [187] = {.index = 486, .length = 5}, + [188] = {.index = 491, .length = 5}, + [189] = {.index = 496, .length = 5}, + [190] = {.index = 501, .length = 6}, + [191] = {.index = 507, .length = 4}, + [192] = {.index = 511, .length = 4}, + [193] = {.index = 515, .length = 5}, + [194] = {.index = 520, .length = 5}, + [195] = {.index = 525, .length = 6}, + [196] = {.index = 531, .length = 5}, + [197] = {.index = 536, .length = 6}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -1932,633 +1958,645 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_callee, 0}, {field_index, 2}, [53] = + {field_variance, 0}, + [54] = + {field_variance, 1, .inherited = true}, + [55] = {field_callee, 0}, {field_type_arguments, 1}, - [55] = + [57] = {field_keyword, 1}, {field_name, 2}, - [57] = + [59] = {field_body, 3}, {field_keyword, 1}, {field_name, 2}, - [60] = + [62] = {field_body, 4}, - [61] = + [63] = {field_name, 1}, {field_variance, 0}, - [63] = + [65] = {field_body, 4}, {field_name, 1}, - [65] = + [67] = {field_name, 2}, - [66] = + [68] = {field_name, 2}, {field_stage, 0}, - [68] = + [70] = {field_body, 2}, {field_operation, 0}, - [70] = + [72] = {field_body, 4}, {field_effect, 1}, - [72] = + [74] = {field_body, 3}, {field_effect, 0}, {field_operation, 1}, - [75] = + [77] = {field_element, 1}, - [76] = + [78] = {field_body, 2}, {field_pattern, 0}, - [78] = + [80] = {field_keyword, 1}, {field_path, 2}, {field_state, 0}, - [81] = + [83] = {field_declaration, 1}, - [82] = + [84] = {field_keyword, 0}, {field_path, 1}, {field_signature, 2}, - [85] = + [87] = {field_condition, 0}, {field_else, 4}, {field_then, 2}, - [88] = + [90] = + {field_variance, 0}, + {field_variance, 2, .inherited = true}, + [92] = + {field_variance, 0, .inherited = true}, + {field_variance, 1, .inherited = true}, + [94] = {field_keyword, 1}, {field_name, 2}, {field_value, 4}, - [91] = + [97] = {field_definition, 4}, {field_name, 2}, - [93] = + [99] = {field_keyword, 1}, {field_path, 2}, - [95] = + [101] = {field_keyword, 0}, {field_name, 1}, {field_type, 3}, {field_value, 5}, - [99] = + [105] = {field_body, 5}, - [100] = + [106] = {field_body, 5}, {field_name, 1}, - [102] = + [108] = {field_body, 5}, {field_effects, 4}, {field_name, 1}, - [105] = + [111] = {field_body, 5}, {field_name, 1}, {field_parameters, 3}, - [108] = + [114] = {field_name, 2}, {field_parameters, 4}, - [110] = + [116] = {field_body, 5}, {field_effect, 2}, {field_stage, 1}, - [113] = + [119] = {field_body, 3}, {field_operation, 0}, - [115] = + [121] = {field_body, 5}, {field_effect, 1}, {field_instantiation, 2}, - [118] = + [124] = {field_body, 4}, {field_effect, 0}, {field_operation, 1}, - [121] = + [127] = {field_element, 1}, {field_element, 2, .inherited = true}, - [123] = + [129] = {field_element, 0, .inherited = true}, {field_element, 1, .inherited = true}, - [125] = + [131] = {field_effect, 1}, {field_operation, 3}, - [127] = + [133] = {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, {field_state, 0}, - [131] = + [137] = {field_declaration, 2}, {field_opaque, 1}, - [133] = + [139] = {field_declaration, 2}, - [134] = + [140] = {field_extra, 3}, {field_path, 1}, - [136] = + [142] = {field_path, 1}, {field_signature, 2}, - [138] = + [144] = {field_name, 2}, {field_opaque, 0}, - [140] = + [146] = + {field_variance, 1}, + [147] = {field_body, 5}, {field_name, 2}, - [142] = + [149] = {field_name, 3}, - [143] = + [150] = {field_name, 3}, {field_stage, 1}, - [145] = + [152] = {field_keyword, 2}, {field_path, 3}, {field_state, 1}, - [148] = + [155] = {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, - [151] = + [158] = {field_alias, 2}, {field_name, 0}, - [153] = + [160] = {field_body, 6}, - [154] = + [161] = {field_body, 6}, {field_name, 1}, {field_return_type, 5}, - [157] = + [164] = {field_body, 6}, {field_effects, 4}, {field_name, 1}, - [160] = + [167] = {field_body, 6}, {field_name, 1}, {field_parameters, 3}, - [163] = + [170] = {field_body, 6}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [167] = + [174] = {field_name, 2}, {field_return_type, 6}, - [169] = + [176] = {field_name, 0}, {field_positional, 2}, - [171] = + [178] = {field_definition, 6}, {field_name, 1}, {field_type_parameters, 3}, - [174] = + [181] = {field_name, 1}, {field_replayable, 0}, {field_type, 3}, - [177] = + [184] = {field_multiplicity, 0}, {field_name, 1}, {field_type, 3}, - [180] = + [187] = {field_name, 1}, {field_type, 3}, - [182] = + [189] = {field_name, 1}, {field_type_parameters, 3}, - [184] = + [191] = {field_alternative, 6}, {field_condition, 1}, {field_consequence, 3}, - [187] = + [194] = {field_body, 6}, {field_effect, 2}, {field_instantiation, 3}, {field_stage, 1}, - [191] = + [198] = {field_effect, 1}, {field_instantiation, 2}, {field_operation, 4}, - [194] = + [201] = {field_declaration, 3}, {field_opaque, 2}, - [196] = + [203] = {field_keyword, 1}, {field_name, 2}, {field_type, 4}, {field_value, 6}, - [200] = + [207] = {field_body, 6}, {field_name, 2}, - [202] = + [209] = {field_body, 6}, {field_effects, 5}, {field_name, 2}, - [205] = + [212] = {field_body, 6}, {field_name, 2}, {field_parameters, 4}, - [208] = + [215] = {field_name, 3}, {field_parameters, 5}, - [210] = + [217] = {field_keyword, 2}, {field_path, 3}, {field_signature, 4}, {field_state, 1}, - [214] = + [221] = {field_body, 7}, - [215] = + [222] = {field_body, 7}, {field_name, 1}, {field_type_parameters, 3}, - [218] = + [225] = {field_body, 7}, {field_name, 1}, {field_return_type, 5}, - [221] = + [228] = {field_body, 7}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [225] = + [232] = {field_body, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [229] = + [236] = {field_body, 7}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [233] = + [240] = {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [236] = + [243] = {field_name, 2}, {field_stage, 0}, {field_type_parameters, 4}, - [239] = + [246] = {field_multiplicity, 0}, {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [243] = + [250] = {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [246] = + [253] = {field_multiplicity, 1}, {field_name, 2}, {field_type, 4}, - [249] = + [256] = {field_element, 1}, {field_rest, 4}, - [251] = + [258] = {field_effects, 4}, {field_name, 1}, - [253] = + [260] = {field_name, 1}, {field_parameters, 3}, - [255] = + [262] = {field_definition, 4}, {field_name, 2}, {field_opaque, 0}, - [258] = + [265] = {field_condition, 0}, - [259] = + [266] = {field_body, 7}, {field_name, 2}, {field_return_type, 6}, - [262] = + [269] = {field_body, 7}, {field_effects, 5}, {field_name, 2}, - [265] = + [272] = {field_body, 7}, {field_name, 2}, {field_parameters, 4}, - [268] = + [275] = {field_body, 7}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [272] = + [279] = {field_name, 3}, {field_return_type, 7}, - [274] = + [281] = {field_definition, 7}, {field_name, 2}, {field_type_parameters, 4}, - [277] = + [284] = {field_name, 2}, {field_type_parameters, 4}, - [279] = + [286] = {field_body, 8}, {field_name, 1}, {field_type_parameters, 3}, - [282] = + [289] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [286] = + [293] = {field_body, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [290] = + [297] = {field_body, 8}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [294] = + [301] = {field_body, 8}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [298] = + [305] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [303] = + [310] = {field_multiplicity, 1}, {field_name, 3}, {field_replayable, 2}, {field_type, 5}, - [307] = + [314] = {field_alternative, 7}, {field_condition, 1}, {field_consequence, 3}, - [310] = + [317] = {field_element, 1}, {field_element, 2, .inherited = true}, {field_rest, 5}, - [313] = + [320] = {field_name, 1}, {field_return_type, 5}, - [315] = + [322] = {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [318] = + [325] = {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [321] = + [328] = {field_body, 8}, {field_name, 2}, {field_type_parameters, 4}, - [324] = + [331] = {field_body, 8}, {field_name, 2}, {field_return_type, 6}, - [327] = + [334] = {field_body, 8}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [331] = + [338] = {field_body, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [335] = + [342] = {field_body, 8}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [339] = + [346] = {field_name, 3}, {field_parameters, 5}, {field_return_type, 8}, - [342] = + [349] = {field_name, 3}, {field_stage, 1}, {field_type_parameters, 5}, - [345] = + [352] = {field_body, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [349] = + [356] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [353] = + [360] = {field_body, 9}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [357] = + [364] = {field_body, 9}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [362] = + [369] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [367] = + [374] = {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [370] = + [377] = {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [373] = + [380] = {field_body, 9}, {field_name, 2}, {field_type_parameters, 4}, - [376] = + [383] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [380] = + [387] = {field_body, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [384] = + [391] = {field_body, 9}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [388] = + [395] = {field_body, 9}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [392] = + [399] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [397] = + [404] = {field_body, 10}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [401] = + [408] = {field_body, 10}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [406] = + [413] = {field_body, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [411] = + [418] = {field_body, 10}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [416] = + [423] = {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [419] = + [426] = {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [422] = + [429] = {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [426] = + [433] = {field_definition, 7}, {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [430] = + [437] = {field_body, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [434] = + [441] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [438] = + [445] = {field_body, 10}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [442] = + [449] = {field_body, 10}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [447] = + [454] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [452] = + [459] = {field_body, 11}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [457] = + [464] = {field_body, 11}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [462] = + [469] = {field_body, 11}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [468] = + [475] = {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [471] = + [478] = {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [475] = + [482] = {field_body, 11}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [479] = + [486] = {field_body, 11}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [484] = + [491] = {field_body, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [489] = + [496] = {field_body, 11}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [494] = + [501] = {field_body, 12}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [500] = + [507] = {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [504] = + [511] = {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [508] = + [515] = {field_body, 12}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [513] = + [520] = {field_body, 12}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [518] = + [525] = {field_body, 12}, {field_effects, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [524] = + [531] = {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [529] = + [536] = {field_body, 13}, {field_effects, 11}, {field_name, 2}, @@ -2569,28 +2607,28 @@ static const TSFieldMapEntry ts_field_map_entries[] = { static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { [0] = {0}, - [59] = { + [63] = { [0] = sym_identifier, }, - [87] = { + [92] = { [1] = sym_identifier, }, - [89] = { + [94] = { [1] = sym_identifier, }, - [91] = { + [96] = { [1] = sym_identifier, }, - [112] = { + [117] = { [2] = sym_identifier, }, - [114] = { + [119] = { [2] = sym_identifier, }, - [116] = { + [121] = { [2] = sym_identifier, }, - [136] = { + [141] = { [3] = sym_identifier, }, }; @@ -2612,43 +2650,43 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [6] = 6, [7] = 7, [8] = 8, - [9] = 9, + [9] = 6, [10] = 10, - [11] = 6, - [12] = 6, - [13] = 6, - [14] = 10, - [15] = 6, - [16] = 9, - [17] = 17, + [11] = 11, + [12] = 12, + [13] = 8, + [14] = 8, + [15] = 12, + [16] = 8, + [17] = 8, [18] = 5, [19] = 5, [20] = 20, [21] = 21, - [22] = 22, + [22] = 21, [23] = 23, - [24] = 24, - [25] = 24, - [26] = 21, - [27] = 22, - [28] = 21, - [29] = 24, - [30] = 23, - [31] = 23, - [32] = 22, + [24] = 23, + [25] = 25, + [26] = 26, + [27] = 26, + [28] = 23, + [29] = 21, + [30] = 25, + [31] = 26, + [32] = 25, [33] = 33, - [34] = 34, + [34] = 33, [35] = 35, [36] = 36, - [37] = 33, - [38] = 38, - [39] = 36, - [40] = 34, - [41] = 35, - [42] = 33, - [43] = 34, - [44] = 35, - [45] = 36, + [37] = 37, + [38] = 36, + [39] = 37, + [40] = 33, + [41] = 37, + [42] = 42, + [43] = 36, + [44] = 42, + [45] = 42, [46] = 46, [47] = 47, [48] = 48, @@ -2664,7 +2702,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [58] = 58, [59] = 59, [60] = 60, - [61] = 46, + [61] = 61, [62] = 62, [63] = 63, [64] = 64, @@ -2675,7 +2713,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [69] = 69, [70] = 70, [71] = 71, - [72] = 72, + [72] = 46, [73] = 73, [74] = 74, [75] = 75, @@ -2722,30 +2760,30 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [116] = 50, [117] = 51, [118] = 53, - [119] = 55, - [120] = 57, - [121] = 62, - [122] = 63, - [123] = 64, - [124] = 65, - [125] = 125, - [126] = 67, - [127] = 68, - [128] = 102, + [119] = 102, + [120] = 55, + [121] = 57, + [122] = 62, + [123] = 63, + [124] = 64, + [125] = 65, + [126] = 126, + [127] = 67, + [128] = 68, [129] = 69, [130] = 70, [131] = 71, [132] = 73, [133] = 74, [134] = 75, - [135] = 135, + [135] = 76, [136] = 77, [137] = 78, [138] = 80, [139] = 81, [140] = 82, [141] = 83, - [142] = 84, + [142] = 142, [143] = 85, [144] = 86, [145] = 87, @@ -2793,7 +2831,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [187] = 187, [188] = 188, [189] = 189, - [190] = 125, + [190] = 126, [191] = 159, [192] = 108, [193] = 182, @@ -2806,34 +2844,34 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [200] = 200, [201] = 201, [202] = 112, - [203] = 135, + [203] = 142, [204] = 200, [205] = 52, [206] = 186, [207] = 47, - [208] = 208, - [209] = 72, - [210] = 135, + [208] = 61, + [209] = 46, + [210] = 142, [211] = 200, [212] = 52, [213] = 186, [214] = 47, - [215] = 46, - [216] = 72, + [215] = 61, + [216] = 216, [217] = 187, [218] = 187, [219] = 201, [220] = 113, - [221] = 221, - [222] = 201, + [221] = 201, + [222] = 222, [223] = 223, - [224] = 125, - [225] = 76, + [224] = 126, + [225] = 84, [226] = 226, [227] = 227, [228] = 228, - [229] = 228, - [230] = 230, + [229] = 229, + [230] = 229, [231] = 231, [232] = 232, [233] = 233, @@ -2895,12 +2933,12 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [289] = 289, [290] = 290, [291] = 291, - [292] = 230, + [292] = 292, [293] = 293, - [294] = 294, + [294] = 228, [295] = 231, [296] = 232, - [297] = 234, + [297] = 297, [298] = 298, [299] = 299, [300] = 300, @@ -2932,84 +2970,84 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [326] = 326, [327] = 327, [328] = 328, - [329] = 250, - [330] = 330, - [331] = 254, - [332] = 238, - [333] = 245, - [334] = 236, - [335] = 235, - [336] = 239, - [337] = 240, + [329] = 329, + [330] = 235, + [331] = 331, + [332] = 236, + [333] = 237, + [334] = 238, + [335] = 240, + [336] = 241, + [337] = 337, [338] = 243, [339] = 244, - [340] = 246, - [341] = 248, - [342] = 249, - [343] = 252, - [344] = 233, - [345] = 345, - [346] = 237, - [347] = 241, - [348] = 242, - [349] = 247, - [350] = 253, - [351] = 251, + [340] = 245, + [341] = 246, + [342] = 247, + [343] = 248, + [344] = 249, + [345] = 250, + [346] = 251, + [347] = 252, + [348] = 253, + [349] = 233, + [350] = 254, + [351] = 255, [352] = 256, - [353] = 353, - [354] = 255, - [355] = 355, - [356] = 356, - [357] = 293, + [353] = 234, + [354] = 354, + [355] = 239, + [356] = 242, + [357] = 281, [358] = 263, - [359] = 294, - [360] = 274, - [361] = 275, - [362] = 276, - [363] = 277, - [364] = 278, - [365] = 264, - [366] = 279, - [367] = 280, - [368] = 281, - [369] = 265, - [370] = 282, - [371] = 266, - [372] = 283, - [373] = 284, - [374] = 267, - [375] = 285, - [376] = 268, - [377] = 260, - [378] = 257, - [379] = 286, - [380] = 287, - [381] = 273, - [382] = 288, - [383] = 289, - [384] = 261, + [359] = 264, + [360] = 265, + [361] = 266, + [362] = 267, + [363] = 268, + [364] = 259, + [365] = 270, + [366] = 271, + [367] = 272, + [368] = 262, + [369] = 274, + [370] = 269, + [371] = 276, + [372] = 277, + [373] = 275, + [374] = 279, + [375] = 257, + [376] = 289, + [377] = 280, + [378] = 282, + [379] = 283, + [380] = 278, + [381] = 285, + [382] = 293, + [383] = 287, + [384] = 288, [385] = 290, - [386] = 258, - [387] = 291, - [388] = 262, - [389] = 270, - [390] = 269, - [391] = 259, - [392] = 271, - [393] = 272, + [386] = 291, + [387] = 292, + [388] = 261, + [389] = 284, + [390] = 258, + [391] = 286, + [392] = 260, + [393] = 273, [394] = 394, [395] = 395, - [396] = 232, - [397] = 231, - [398] = 255, + [396] = 231, + [397] = 232, + [398] = 239, [399] = 399, [400] = 400, [401] = 401, [402] = 402, - [403] = 230, + [403] = 400, [404] = 404, [405] = 405, - [406] = 406, + [406] = 228, [407] = 407, [408] = 408, [409] = 409, @@ -3020,216 +3058,216 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [414] = 414, [415] = 415, [416] = 416, - [417] = 400, - [418] = 418, + [417] = 404, + [418] = 413, [419] = 419, - [420] = 420, - [421] = 419, - [422] = 418, - [423] = 404, - [424] = 405, - [425] = 416, - [426] = 406, - [427] = 408, - [428] = 415, - [429] = 401, - [430] = 402, - [431] = 407, - [432] = 411, - [433] = 412, - [434] = 434, - [435] = 420, - [436] = 434, - [437] = 232, + [420] = 409, + [421] = 410, + [422] = 412, + [423] = 414, + [424] = 401, + [425] = 402, + [426] = 426, + [427] = 427, + [428] = 419, + [429] = 426, + [430] = 430, + [431] = 431, + [432] = 430, + [433] = 415, + [434] = 416, + [435] = 431, + [436] = 427, + [437] = 437, [438] = 231, - [439] = 439, - [440] = 440, - [441] = 238, - [442] = 255, - [443] = 237, - [444] = 444, - [445] = 251, - [446] = 241, - [447] = 245, - [448] = 448, - [449] = 252, - [450] = 242, + [439] = 232, + [440] = 239, + [441] = 441, + [442] = 236, + [443] = 252, + [444] = 238, + [445] = 445, + [446] = 248, + [447] = 250, + [448] = 237, + [449] = 253, + [450] = 235, [451] = 247, - [452] = 440, - [453] = 254, - [454] = 249, - [455] = 234, - [456] = 248, + [452] = 246, + [453] = 453, + [454] = 454, + [455] = 233, + [456] = 251, [457] = 457, - [458] = 253, - [459] = 233, - [460] = 250, - [461] = 246, - [462] = 256, - [463] = 440, - [464] = 457, - [465] = 236, - [466] = 235, - [467] = 457, - [468] = 239, - [469] = 240, - [470] = 243, - [471] = 244, - [472] = 472, - [473] = 258, - [474] = 283, - [475] = 293, - [476] = 284, - [477] = 273, - [478] = 270, - [479] = 261, - [480] = 279, - [481] = 285, - [482] = 280, - [483] = 294, - [484] = 267, - [485] = 274, - [486] = 281, - [487] = 287, - [488] = 266, - [489] = 489, - [490] = 490, - [491] = 262, - [492] = 275, - [493] = 259, - [494] = 263, - [495] = 264, + [458] = 242, + [459] = 243, + [460] = 249, + [461] = 254, + [462] = 445, + [463] = 457, + [464] = 255, + [465] = 244, + [466] = 245, + [467] = 445, + [468] = 256, + [469] = 457, + [470] = 234, + [471] = 240, + [472] = 241, + [473] = 473, + [474] = 287, + [475] = 282, + [476] = 283, + [477] = 477, + [478] = 264, + [479] = 265, + [480] = 480, + [481] = 481, + [482] = 482, + [483] = 268, + [484] = 286, + [485] = 279, + [486] = 270, + [487] = 487, + [488] = 278, + [489] = 289, + [490] = 262, + [491] = 271, + [492] = 492, + [493] = 274, + [494] = 272, + [495] = 487, [496] = 496, [497] = 276, [498] = 498, - [499] = 282, - [500] = 288, - [501] = 289, - [502] = 502, - [503] = 503, - [504] = 504, - [505] = 490, - [506] = 506, - [507] = 504, - [508] = 257, - [509] = 286, - [510] = 272, - [511] = 489, - [512] = 512, - [513] = 277, - [514] = 260, - [515] = 290, - [516] = 265, - [517] = 268, + [499] = 266, + [500] = 291, + [501] = 258, + [502] = 280, + [503] = 260, + [504] = 277, + [505] = 257, + [506] = 269, + [507] = 481, + [508] = 482, + [509] = 285, + [510] = 273, + [511] = 292, + [512] = 288, + [513] = 481, + [514] = 267, + [515] = 481, + [516] = 263, + [517] = 259, [518] = 518, - [519] = 504, - [520] = 490, - [521] = 504, - [522] = 504, - [523] = 291, - [524] = 278, - [525] = 269, - [526] = 271, - [527] = 317, - [528] = 345, - [529] = 324, - [530] = 530, - [531] = 356, - [532] = 319, - [533] = 533, - [534] = 307, - [535] = 320, - [536] = 325, - [537] = 298, - [538] = 538, + [519] = 482, + [520] = 281, + [521] = 290, + [522] = 481, + [523] = 275, + [524] = 284, + [525] = 293, + [526] = 261, + [527] = 337, + [528] = 528, + [529] = 329, + [530] = 313, + [531] = 302, + [532] = 314, + [533] = 309, + [534] = 534, + [535] = 535, + [536] = 315, + [537] = 316, + [538] = 308, [539] = 539, - [540] = 540, - [541] = 330, - [542] = 542, + [540] = 317, + [541] = 541, + [542] = 310, [543] = 543, - [544] = 544, - [545] = 530, + [544] = 318, + [545] = 545, [546] = 546, [547] = 547, [548] = 548, [549] = 549, - [550] = 550, + [550] = 539, [551] = 551, - [552] = 299, + [552] = 545, [553] = 553, - [554] = 353, - [555] = 321, - [556] = 546, - [557] = 326, - [558] = 558, - [559] = 322, - [560] = 560, - [561] = 539, - [562] = 553, - [563] = 563, - [564] = 300, - [565] = 327, - [566] = 563, - [567] = 318, - [568] = 539, - [569] = 302, - [570] = 303, - [571] = 571, - [572] = 543, - [573] = 544, - [574] = 530, - [575] = 546, - [576] = 560, - [577] = 548, - [578] = 549, - [579] = 304, - [580] = 551, - [581] = 553, - [582] = 543, - [583] = 544, - [584] = 560, - [585] = 563, - [586] = 305, - [587] = 306, - [588] = 355, - [589] = 548, - [590] = 590, - [591] = 328, - [592] = 308, - [593] = 301, - [594] = 551, - [595] = 309, - [596] = 323, - [597] = 310, - [598] = 311, - [599] = 549, - [600] = 312, - [601] = 313, - [602] = 558, - [603] = 542, - [604] = 604, - [605] = 558, - [606] = 542, - [607] = 314, - [608] = 315, - [609] = 316, + [554] = 554, + [555] = 546, + [556] = 554, + [557] = 319, + [558] = 553, + [559] = 559, + [560] = 297, + [561] = 331, + [562] = 562, + [563] = 549, + [564] = 543, + [565] = 307, + [566] = 566, + [567] = 567, + [568] = 547, + [569] = 298, + [570] = 301, + [571] = 543, + [572] = 321, + [573] = 548, + [574] = 322, + [575] = 545, + [576] = 546, + [577] = 547, + [578] = 548, + [579] = 323, + [580] = 539, + [581] = 551, + [582] = 320, + [583] = 553, + [584] = 554, + [585] = 324, + [586] = 549, + [587] = 566, + [588] = 311, + [589] = 312, + [590] = 325, + [591] = 326, + [592] = 354, + [593] = 306, + [594] = 594, + [595] = 595, + [596] = 299, + [597] = 300, + [598] = 598, + [599] = 566, + [600] = 327, + [601] = 328, + [602] = 567, + [603] = 562, + [604] = 567, + [605] = 562, + [606] = 303, + [607] = 304, + [608] = 305, + [609] = 551, [610] = 610, [611] = 611, [612] = 612, [613] = 613, [614] = 614, - [615] = 615, - [616] = 613, + [615] = 614, + [616] = 616, [617] = 617, - [618] = 615, - [619] = 613, - [620] = 615, + [618] = 618, + [619] = 616, + [620] = 614, [621] = 621, [622] = 622, [623] = 623, - [624] = 612, - [625] = 625, - [626] = 612, + [624] = 613, + [625] = 616, + [626] = 613, [627] = 627, [628] = 628, [629] = 629, @@ -3240,38 +3278,38 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [634] = 634, [635] = 635, [636] = 636, - [637] = 637, - [638] = 635, - [639] = 639, - [640] = 639, - [641] = 641, - [642] = 637, - [643] = 641, + [637] = 636, + [638] = 638, + [639] = 635, + [640] = 640, + [641] = 638, + [642] = 642, + [643] = 640, [644] = 644, [645] = 645, [646] = 646, [647] = 647, [648] = 648, - [649] = 649, + [649] = 437, [650] = 650, - [651] = 651, - [652] = 652, - [653] = 232, - [654] = 231, + [651] = 231, + [652] = 232, + [653] = 653, + [654] = 654, [655] = 655, [656] = 656, - [657] = 439, + [657] = 657, [658] = 658, [659] = 659, [660] = 660, [661] = 661, - [662] = 659, + [662] = 662, [663] = 663, [664] = 664, [665] = 665, [666] = 666, [667] = 667, - [668] = 668, + [668] = 667, [669] = 669, [670] = 670, [671] = 671, @@ -3284,17 +3322,17 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [678] = 678, [679] = 679, [680] = 680, - [681] = 669, + [681] = 681, [682] = 682, [683] = 683, [684] = 684, - [685] = 255, - [686] = 675, - [687] = 687, - [688] = 687, + [685] = 675, + [686] = 239, + [687] = 684, + [688] = 661, [689] = 689, [690] = 690, - [691] = 503, + [691] = 691, [692] = 692, [693] = 693, [694] = 694, @@ -3356,18 +3394,18 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [750] = 750, [751] = 751, [752] = 752, - [753] = 262, - [754] = 270, + [753] = 284, + [754] = 258, [755] = 755, - [756] = 756, + [756] = 518, [757] = 757, [758] = 758, [759] = 759, [760] = 760, - [761] = 232, + [761] = 761, [762] = 762, [763] = 763, - [764] = 764, + [764] = 231, [765] = 765, [766] = 766, [767] = 767, @@ -3375,72 +3413,72 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [769] = 769, [770] = 770, [771] = 771, - [772] = 760, - [773] = 231, + [772] = 772, + [773] = 773, [774] = 232, - [775] = 775, + [775] = 231, [776] = 776, [777] = 777, - [778] = 766, + [778] = 760, [779] = 779, [780] = 780, - [781] = 770, - [782] = 775, + [781] = 765, + [782] = 782, [783] = 783, - [784] = 764, - [785] = 769, - [786] = 786, - [787] = 787, - [788] = 780, - [789] = 789, - [790] = 762, - [791] = 763, - [792] = 771, - [793] = 777, - [794] = 786, - [795] = 787, - [796] = 796, - [797] = 796, - [798] = 776, + [784] = 784, + [785] = 783, + [786] = 773, + [787] = 779, + [788] = 772, + [789] = 761, + [790] = 790, + [791] = 780, + [792] = 762, + [793] = 766, + [794] = 768, + [795] = 770, + [796] = 771, + [797] = 784, + [798] = 798, [799] = 799, - [800] = 783, - [801] = 801, - [802] = 802, - [803] = 617, - [804] = 625, + [800] = 800, + [801] = 777, + [802] = 776, + [803] = 803, + [804] = 804, [805] = 805, - [806] = 806, - [807] = 622, - [808] = 623, - [809] = 611, - [810] = 255, - [811] = 255, + [806] = 239, + [807] = 807, + [808] = 239, + [809] = 621, + [810] = 810, + [811] = 811, [812] = 812, - [813] = 813, + [813] = 618, [814] = 814, [815] = 815, - [816] = 814, - [817] = 815, - [818] = 818, - [819] = 814, + [816] = 816, + [817] = 617, + [818] = 811, + [819] = 611, [820] = 820, - [821] = 815, - [822] = 822, - [823] = 823, - [824] = 824, - [825] = 231, + [821] = 811, + [822] = 820, + [823] = 612, + [824] = 820, + [825] = 825, [826] = 826, - [827] = 827, + [827] = 232, [828] = 828, [829] = 829, [830] = 830, - [831] = 830, - [832] = 823, - [833] = 833, - [834] = 826, - [835] = 835, - [836] = 836, - [837] = 830, + [831] = 831, + [832] = 830, + [833] = 825, + [834] = 834, + [835] = 828, + [836] = 830, + [837] = 837, [838] = 838, [839] = 839, [840] = 840, @@ -3448,7 +3486,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [842] = 842, [843] = 843, [844] = 844, - [845] = 621, + [845] = 841, [846] = 846, [847] = 847, [848] = 848, @@ -3459,26 +3497,26 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [853] = 853, [854] = 854, [855] = 855, - [856] = 847, + [856] = 856, [857] = 857, [858] = 858, - [859] = 859, + [859] = 858, [860] = 860, [861] = 861, - [862] = 861, + [862] = 232, [863] = 863, - [864] = 864, + [864] = 231, [865] = 865, - [866] = 231, - [867] = 232, + [866] = 866, + [867] = 867, [868] = 868, - [869] = 851, + [869] = 869, [870] = 870, [871] = 871, [872] = 872, [873] = 873, - [874] = 851, - [875] = 875, + [874] = 874, + [875] = 852, [876] = 876, [877] = 877, [878] = 878, @@ -3491,64 +3529,64 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [885] = 885, [886] = 886, [887] = 887, - [888] = 861, - [889] = 846, - [890] = 868, + [888] = 854, + [889] = 889, + [890] = 890, [891] = 891, [892] = 892, - [893] = 885, - [894] = 894, + [893] = 893, + [894] = 880, [895] = 895, [896] = 896, [897] = 897, [898] = 898, - [899] = 899, + [899] = 857, [900] = 900, [901] = 901, [902] = 902, [903] = 903, [904] = 904, - [905] = 871, + [905] = 905, [906] = 906, - [907] = 840, + [907] = 907, [908] = 908, [909] = 909, - [910] = 857, - [911] = 896, + [910] = 910, + [911] = 911, [912] = 912, [913] = 913, - [914] = 904, - [915] = 841, - [916] = 865, - [917] = 870, - [918] = 892, - [919] = 900, - [920] = 920, - [921] = 920, - [922] = 922, - [923] = 923, - [924] = 840, - [925] = 847, - [926] = 886, - [927] = 839, - [928] = 896, - [929] = 839, - [930] = 930, + [914] = 914, + [915] = 874, + [916] = 916, + [917] = 858, + [918] = 855, + [919] = 877, + [920] = 902, + [921] = 903, + [922] = 623, + [923] = 850, + [924] = 853, + [925] = 913, + [926] = 926, + [927] = 842, + [928] = 860, + [929] = 873, + [930] = 887, [931] = 931, - [932] = 932, - [933] = 912, - [934] = 934, - [935] = 935, - [936] = 936, - [937] = 752, - [938] = 255, + [932] = 874, + [933] = 841, + [934] = 855, + [935] = 902, + [936] = 926, + [937] = 896, + [938] = 852, [939] = 939, - [940] = 940, - [941] = 941, - [942] = 942, + [940] = 239, + [941] = 706, + [942] = 632, [943] = 943, [944] = 944, - [945] = 945, + [945] = 631, [946] = 946, [947] = 947, [948] = 948, @@ -3557,22 +3595,22 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [951] = 951, [952] = 952, [953] = 953, - [954] = 634, - [955] = 633, - [956] = 956, + [954] = 954, + [955] = 955, + [956] = 955, [957] = 957, [958] = 958, - [959] = 947, + [959] = 959, [960] = 960, - [961] = 951, + [961] = 961, [962] = 962, [963] = 963, [964] = 964, - [965] = 947, + [965] = 953, [966] = 966, - [967] = 951, + [967] = 955, [968] = 968, - [969] = 818, + [969] = 953, [970] = 970, [971] = 971, [972] = 972, @@ -3580,307 +3618,307 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [974] = 974, [975] = 975, [976] = 976, - [977] = 970, - [978] = 978, - [979] = 973, - [980] = 439, + [977] = 974, + [978] = 807, + [979] = 976, + [980] = 884, [981] = 981, - [982] = 978, - [983] = 975, - [984] = 984, - [985] = 984, - [986] = 895, - [987] = 981, - [988] = 974, - [989] = 976, - [990] = 767, + [982] = 981, + [983] = 983, + [984] = 437, + [985] = 973, + [986] = 986, + [987] = 987, + [988] = 975, + [989] = 987, + [990] = 986, [991] = 991, - [992] = 992, + [992] = 972, [993] = 993, [994] = 994, [995] = 995, [996] = 996, - [997] = 994, + [997] = 997, [998] = 998, [999] = 999, [1000] = 1000, [1001] = 1001, [1002] = 1002, - [1003] = 996, + [1003] = 997, [1004] = 1004, - [1005] = 644, + [1005] = 1005, [1006] = 1006, [1007] = 1007, - [1008] = 991, - [1009] = 1009, + [1008] = 1008, + [1009] = 644, [1010] = 1010, [1011] = 1011, [1012] = 1012, - [1013] = 1013, + [1013] = 1012, [1014] = 1014, [1015] = 1015, [1016] = 1016, - [1017] = 1010, + [1017] = 1016, [1018] = 1018, - [1019] = 1000, - [1020] = 1004, + [1019] = 1019, + [1020] = 1020, [1021] = 1021, - [1022] = 998, - [1023] = 1011, - [1024] = 1021, - [1025] = 995, - [1026] = 1018, - [1027] = 1027, + [1022] = 1022, + [1023] = 998, + [1024] = 1004, + [1025] = 1025, + [1026] = 1025, + [1027] = 997, [1028] = 1028, - [1029] = 1029, - [1030] = 1030, - [1031] = 1031, - [1032] = 1009, - [1033] = 1018, - [1034] = 1013, - [1035] = 1014, - [1036] = 1000, - [1037] = 779, - [1038] = 1029, - [1039] = 1021, - [1040] = 1030, - [1041] = 1041, - [1042] = 1041, - [1043] = 993, - [1044] = 1015, - [1045] = 1007, - [1046] = 1001, - [1047] = 1030, - [1048] = 1048, - [1049] = 992, - [1050] = 1048, - [1051] = 995, - [1052] = 1012, - [1053] = 1053, - [1054] = 1027, + [1029] = 1001, + [1030] = 1002, + [1031] = 1006, + [1032] = 993, + [1033] = 1033, + [1034] = 1001, + [1035] = 1018, + [1036] = 1011, + [1037] = 1037, + [1038] = 1021, + [1039] = 799, + [1040] = 1006, + [1041] = 1002, + [1042] = 1028, + [1043] = 1043, + [1044] = 1043, + [1045] = 1000, + [1046] = 995, + [1047] = 1047, + [1048] = 1014, + [1049] = 1020, + [1050] = 1050, + [1051] = 1018, + [1052] = 1011, + [1053] = 1015, + [1054] = 1021, [1055] = 1055, - [1056] = 1056, - [1057] = 647, - [1058] = 1058, - [1059] = 1059, - [1060] = 645, - [1061] = 1061, + [1056] = 1043, + [1057] = 1022, + [1058] = 800, + [1059] = 1050, + [1060] = 1007, + [1061] = 1019, [1062] = 1062, - [1063] = 1063, - [1064] = 1064, + [1063] = 1005, + [1064] = 1008, [1065] = 1065, - [1066] = 1066, + [1066] = 1019, [1067] = 1067, - [1068] = 1068, - [1069] = 1069, - [1070] = 1070, + [1068] = 1055, + [1069] = 999, + [1070] = 1065, [1071] = 1071, - [1072] = 1072, + [1072] = 645, [1073] = 1073, [1074] = 1074, [1075] = 1075, - [1076] = 1065, - [1077] = 1070, + [1076] = 1076, + [1077] = 1077, [1078] = 1078, - [1079] = 1072, - [1080] = 1071, + [1079] = 1079, + [1080] = 1080, [1081] = 1081, [1082] = 1082, [1083] = 1083, - [1084] = 1084, - [1085] = 1085, + [1084] = 1080, + [1085] = 892, [1086] = 1086, - [1087] = 1063, + [1087] = 1087, [1088] = 1088, [1089] = 1089, [1090] = 1090, - [1091] = 293, + [1091] = 1091, [1092] = 1092, [1093] = 1093, - [1094] = 1063, - [1095] = 1095, + [1094] = 1094, + [1095] = 518, [1096] = 1096, [1097] = 1097, - [1098] = 1064, + [1098] = 1098, [1099] = 1099, - [1100] = 1070, - [1101] = 1071, - [1102] = 1065, + [1100] = 1089, + [1101] = 1101, + [1102] = 1086, [1103] = 1103, [1104] = 1104, [1105] = 1105, - [1106] = 503, - [1107] = 1067, - [1108] = 880, - [1109] = 646, - [1110] = 1110, - [1111] = 1110, + [1106] = 1089, + [1107] = 1107, + [1108] = 1108, + [1109] = 1109, + [1110] = 1103, + [1111] = 1111, [1112] = 1112, - [1113] = 1074, - [1114] = 1064, + [1113] = 646, + [1114] = 1114, [1115] = 1115, - [1116] = 1116, - [1117] = 1117, + [1116] = 647, + [1117] = 261, [1118] = 1118, [1119] = 1119, - [1120] = 1120, + [1120] = 1104, [1121] = 1121, [1122] = 1122, [1123] = 1123, [1124] = 1124, [1125] = 1125, [1126] = 1126, - [1127] = 1127, + [1127] = 657, [1128] = 1128, [1129] = 1129, [1130] = 1130, [1131] = 1131, [1132] = 1132, [1133] = 1133, - [1134] = 650, + [1134] = 1134, [1135] = 1135, [1136] = 1136, - [1137] = 1120, - [1138] = 1138, + [1137] = 1137, + [1138] = 1133, [1139] = 1139, [1140] = 1140, [1141] = 1141, - [1142] = 1142, - [1143] = 1143, + [1142] = 653, + [1143] = 1122, [1144] = 1144, [1145] = 1145, [1146] = 1146, [1147] = 1147, [1148] = 1148, [1149] = 1149, - [1150] = 1128, + [1150] = 1150, [1151] = 1151, [1152] = 1152, [1153] = 1126, [1154] = 1154, - [1155] = 1145, + [1155] = 1155, [1156] = 1156, - [1157] = 1131, + [1157] = 1157, [1158] = 1158, [1159] = 1159, - [1160] = 1156, + [1160] = 1160, [1161] = 1161, [1162] = 1162, [1163] = 1163, [1164] = 1164, [1165] = 1165, [1166] = 1166, - [1167] = 1124, + [1167] = 1167, [1168] = 1168, [1169] = 1169, - [1170] = 1170, - [1171] = 1171, - [1172] = 1172, - [1173] = 1132, - [1174] = 1132, + [1170] = 648, + [1171] = 1136, + [1172] = 654, + [1173] = 1173, + [1174] = 1174, [1175] = 1175, - [1176] = 1176, - [1177] = 1177, - [1178] = 1148, + [1176] = 1173, + [1177] = 1149, + [1178] = 1155, [1179] = 1179, - [1180] = 1164, + [1180] = 1180, [1181] = 1181, [1182] = 1182, [1183] = 1183, - [1184] = 1161, - [1185] = 1185, + [1184] = 1184, + [1185] = 1159, [1186] = 1186, [1187] = 1187, - [1188] = 1139, - [1189] = 1189, - [1190] = 1120, - [1191] = 1163, + [1188] = 1188, + [1189] = 1160, + [1190] = 1190, + [1191] = 1191, [1192] = 1192, - [1193] = 1165, + [1193] = 1193, [1194] = 1194, [1195] = 1195, - [1196] = 1159, - [1197] = 1189, - [1198] = 1198, - [1199] = 1199, + [1196] = 1158, + [1197] = 1169, + [1198] = 1183, + [1199] = 1148, [1200] = 1200, - [1201] = 1201, - [1202] = 1154, - [1203] = 1186, - [1204] = 1146, + [1201] = 1188, + [1202] = 650, + [1203] = 1203, + [1204] = 1165, [1205] = 1205, - [1206] = 1206, - [1207] = 1207, - [1208] = 1201, + [1206] = 655, + [1207] = 1193, + [1208] = 1208, [1209] = 1209, - [1210] = 656, - [1211] = 1144, - [1212] = 1206, + [1210] = 1129, + [1211] = 1211, + [1212] = 656, [1213] = 1213, [1214] = 1214, - [1215] = 1215, + [1215] = 1165, [1216] = 1216, - [1217] = 1217, - [1218] = 655, - [1219] = 1219, - [1220] = 648, + [1217] = 1133, + [1218] = 1187, + [1219] = 1216, + [1220] = 1182, [1221] = 1221, - [1222] = 652, - [1223] = 1205, + [1222] = 1222, + [1223] = 1174, [1224] = 1224, - [1225] = 1225, - [1226] = 1226, - [1227] = 1194, - [1228] = 1228, - [1229] = 1171, - [1230] = 649, - [1231] = 1164, - [1232] = 1168, - [1233] = 1189, - [1234] = 1125, - [1235] = 1200, - [1236] = 1154, + [1225] = 1149, + [1226] = 1146, + [1227] = 1227, + [1228] = 1182, + [1229] = 1155, + [1230] = 1159, + [1231] = 1231, + [1232] = 1160, + [1233] = 1233, + [1234] = 1205, + [1235] = 1235, + [1236] = 1236, [1237] = 1237, - [1238] = 1205, - [1239] = 1209, + [1238] = 1238, + [1239] = 1239, [1240] = 1240, - [1241] = 1241, + [1241] = 1227, [1242] = 1242, - [1243] = 1194, - [1244] = 1148, - [1245] = 1179, - [1246] = 1169, - [1247] = 1119, - [1248] = 1179, - [1249] = 1249, + [1243] = 1243, + [1244] = 1244, + [1245] = 1136, + [1246] = 1186, + [1247] = 1227, + [1248] = 1248, + [1249] = 1237, [1250] = 1250, - [1251] = 651, - [1252] = 1219, - [1253] = 1135, - [1254] = 1254, - [1255] = 1255, - [1256] = 1213, - [1257] = 1127, - [1258] = 1219, - [1259] = 1170, - [1260] = 1200, - [1261] = 1209, + [1251] = 1235, + [1252] = 1130, + [1253] = 1192, + [1254] = 1129, + [1255] = 1152, + [1256] = 1222, + [1257] = 1167, + [1258] = 1258, + [1259] = 1141, + [1260] = 1130, + [1261] = 1147, [1262] = 1262, [1263] = 1263, - [1264] = 668, - [1265] = 1265, + [1264] = 1179, + [1265] = 1123, [1266] = 1266, - [1267] = 1267, - [1268] = 625, - [1269] = 1269, + [1267] = 1125, + [1268] = 1268, + [1269] = 1174, [1270] = 1270, [1271] = 1271, - [1272] = 1272, + [1272] = 662, [1273] = 1273, - [1274] = 1274, - [1275] = 674, + [1274] = 659, + [1275] = 1275, [1276] = 1276, - [1277] = 1277, + [1277] = 670, [1278] = 1278, [1279] = 1279, [1280] = 1280, @@ -3891,469 +3929,479 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1285] = 1285, [1286] = 1286, [1287] = 1287, - [1288] = 611, - [1289] = 1289, + [1288] = 1288, + [1289] = 1278, [1290] = 1290, [1291] = 1291, - [1292] = 891, + [1292] = 1292, [1293] = 1293, [1294] = 1294, - [1295] = 622, - [1296] = 923, - [1297] = 1297, - [1298] = 671, - [1299] = 1273, + [1295] = 1295, + [1296] = 1296, + [1297] = 1287, + [1298] = 1298, + [1299] = 1299, [1300] = 1300, [1301] = 1301, - [1302] = 1266, + [1302] = 1302, [1303] = 1303, - [1304] = 1304, - [1305] = 663, - [1306] = 1262, - [1307] = 1286, - [1308] = 1308, + [1304] = 674, + [1305] = 1305, + [1306] = 617, + [1307] = 618, + [1308] = 621, [1309] = 1309, - [1310] = 1310, + [1310] = 879, [1311] = 1311, - [1312] = 660, + [1312] = 1312, [1313] = 1313, - [1314] = 1297, - [1315] = 1315, + [1314] = 611, + [1315] = 1290, [1316] = 1316, - [1317] = 833, + [1317] = 838, [1318] = 1318, - [1319] = 1308, + [1319] = 612, [1320] = 1290, [1321] = 1321, - [1322] = 1265, - [1323] = 1316, + [1322] = 1322, + [1323] = 1295, [1324] = 1324, - [1325] = 1324, - [1326] = 1326, - [1327] = 1283, - [1328] = 1328, - [1329] = 1329, - [1330] = 1287, + [1325] = 1325, + [1326] = 1293, + [1327] = 1327, + [1328] = 1294, + [1329] = 886, + [1330] = 1316, [1331] = 1331, [1332] = 1332, - [1333] = 1265, - [1334] = 1334, + [1333] = 1333, + [1334] = 665, [1335] = 1335, - [1336] = 1311, - [1337] = 1337, + [1336] = 1336, + [1337] = 666, [1338] = 1338, - [1339] = 1293, - [1340] = 1328, - [1341] = 1286, - [1342] = 1303, - [1343] = 1343, - [1344] = 1237, + [1339] = 1332, + [1340] = 1340, + [1341] = 1341, + [1342] = 1342, + [1343] = 1270, + [1344] = 1336, [1345] = 1345, - [1346] = 623, + [1346] = 1331, [1347] = 1347, - [1348] = 1266, - [1349] = 1313, + [1348] = 1341, + [1349] = 1349, [1350] = 1350, - [1351] = 1263, - [1352] = 1301, - [1353] = 617, - [1354] = 1313, - [1355] = 667, - [1356] = 1263, - [1357] = 1357, - [1358] = 1321, - [1359] = 1359, - [1360] = 1360, - [1361] = 1361, + [1351] = 1351, + [1352] = 1350, + [1353] = 1303, + [1354] = 1354, + [1355] = 1309, + [1356] = 1283, + [1357] = 1354, + [1358] = 1327, + [1359] = 1333, + [1360] = 1354, + [1361] = 1295, [1362] = 1362, [1363] = 1363, - [1364] = 736, - [1365] = 1365, - [1366] = 1366, + [1364] = 1342, + [1365] = 1180, + [1366] = 1270, [1367] = 1367, - [1368] = 1368, + [1368] = 1342, [1369] = 1369, [1370] = 1370, [1371] = 1371, - [1372] = 717, + [1372] = 1372, [1373] = 1373, - [1374] = 1374, + [1374] = 690, [1375] = 1375, - [1376] = 737, - [1377] = 1377, - [1378] = 695, - [1379] = 1375, + [1376] = 1376, + [1377] = 671, + [1378] = 1378, + [1379] = 1379, [1380] = 1380, [1381] = 1381, [1382] = 1382, - [1383] = 1383, - [1384] = 738, + [1383] = 701, + [1384] = 1384, [1385] = 1385, [1386] = 1386, - [1387] = 1387, - [1388] = 697, - [1389] = 739, - [1390] = 684, + [1387] = 740, + [1388] = 1388, + [1389] = 1389, + [1390] = 1390, [1391] = 1391, [1392] = 1392, [1393] = 1393, [1394] = 1394, [1395] = 1395, - [1396] = 658, - [1397] = 741, + [1396] = 1396, + [1397] = 672, [1398] = 1398, [1399] = 1399, - [1400] = 742, - [1401] = 672, + [1400] = 1400, + [1401] = 1401, [1402] = 1402, - [1403] = 1403, + [1403] = 1378, [1404] = 1404, [1405] = 1405, - [1406] = 1406, - [1407] = 1407, - [1408] = 698, - [1409] = 1409, - [1410] = 718, - [1411] = 699, - [1412] = 700, + [1406] = 746, + [1407] = 693, + [1408] = 1408, + [1409] = 725, + [1410] = 702, + [1411] = 727, + [1412] = 1408, [1413] = 1413, - [1414] = 743, - [1415] = 701, + [1414] = 1414, + [1415] = 1415, [1416] = 1416, - [1417] = 1402, - [1418] = 722, - [1419] = 1419, - [1420] = 744, - [1421] = 1421, + [1417] = 1417, + [1418] = 1418, + [1419] = 703, + [1420] = 694, + [1421] = 695, [1422] = 1422, - [1423] = 1423, - [1424] = 1380, + [1423] = 676, + [1424] = 1424, [1425] = 1425, [1426] = 1426, - [1427] = 1427, - [1428] = 1428, - [1429] = 745, - [1430] = 1430, + [1427] = 707, + [1428] = 708, + [1429] = 696, + [1430] = 1401, [1431] = 1431, - [1432] = 1387, - [1433] = 1394, - [1434] = 702, + [1432] = 1432, + [1433] = 692, + [1434] = 691, [1435] = 1435, - [1436] = 727, - [1437] = 746, - [1438] = 1438, - [1439] = 1404, - [1440] = 1435, - [1441] = 747, + [1436] = 709, + [1437] = 1437, + [1438] = 1422, + [1439] = 1414, + [1440] = 1440, + [1441] = 1405, [1442] = 1442, - [1443] = 1381, - [1444] = 1405, - [1445] = 1445, - [1446] = 703, - [1447] = 704, - [1448] = 1406, - [1449] = 1449, - [1450] = 750, + [1443] = 1375, + [1444] = 710, + [1445] = 1415, + [1446] = 1416, + [1447] = 1447, + [1448] = 712, + [1449] = 663, + [1450] = 1450, [1451] = 1451, [1452] = 1452, [1453] = 1453, [1454] = 1454, - [1455] = 1455, - [1456] = 1456, + [1455] = 1382, + [1456] = 713, [1457] = 1457, - [1458] = 1458, - [1459] = 1360, - [1460] = 1382, - [1461] = 661, + [1458] = 715, + [1459] = 1459, + [1460] = 716, + [1461] = 677, [1462] = 1462, - [1463] = 1407, + [1463] = 1463, [1464] = 1464, [1465] = 1465, [1466] = 1466, [1467] = 1467, - [1468] = 1468, + [1468] = 734, [1469] = 1469, [1470] = 1470, [1471] = 1471, - [1472] = 1472, + [1472] = 678, [1473] = 1473, - [1474] = 1474, - [1475] = 673, - [1476] = 666, + [1474] = 1417, + [1475] = 1475, + [1476] = 1476, [1477] = 1477, [1478] = 1478, - [1479] = 1479, + [1479] = 697, [1480] = 1480, [1481] = 1481, - [1482] = 1482, + [1482] = 1450, [1483] = 1483, - [1484] = 733, + [1484] = 1484, [1485] = 1485, - [1486] = 1409, + [1486] = 722, [1487] = 1487, - [1488] = 734, + [1488] = 664, [1489] = 1489, - [1490] = 1490, + [1490] = 719, [1491] = 1491, [1492] = 1492, - [1493] = 1445, - [1494] = 705, - [1495] = 1495, - [1496] = 1451, - [1497] = 1490, - [1498] = 1498, - [1499] = 1482, - [1500] = 1500, + [1493] = 1493, + [1494] = 1494, + [1495] = 700, + [1496] = 1496, + [1497] = 720, + [1498] = 721, + [1499] = 1499, + [1500] = 1465, [1501] = 1501, [1502] = 1502, - [1503] = 1503, - [1504] = 1370, - [1505] = 1416, + [1503] = 704, + [1504] = 1504, + [1505] = 660, [1506] = 1506, - [1507] = 1507, + [1507] = 679, [1508] = 1508, - [1509] = 1363, + [1509] = 723, [1510] = 1510, - [1511] = 740, + [1511] = 1511, [1512] = 1512, - [1513] = 1363, - [1514] = 1375, - [1515] = 1380, - [1516] = 1381, - [1517] = 1382, - [1518] = 1386, - [1519] = 1386, - [1520] = 706, - [1521] = 262, - [1522] = 1404, - [1523] = 1405, - [1524] = 1406, - [1525] = 1416, - [1526] = 1526, - [1527] = 1425, - [1528] = 1528, - [1529] = 1428, - [1530] = 1530, - [1531] = 1445, - [1532] = 707, - [1533] = 1533, - [1534] = 1490, - [1535] = 1535, - [1536] = 755, - [1537] = 1490, - [1538] = 676, - [1539] = 1490, - [1540] = 1490, - [1541] = 1490, + [1513] = 724, + [1514] = 1372, + [1515] = 1515, + [1516] = 1516, + [1517] = 1517, + [1518] = 759, + [1519] = 1373, + [1520] = 1520, + [1521] = 1426, + [1522] = 698, + [1523] = 1373, + [1524] = 1389, + [1525] = 1390, + [1526] = 1391, + [1527] = 1392, + [1528] = 1396, + [1529] = 1496, + [1530] = 699, + [1531] = 726, + [1532] = 1414, + [1533] = 1415, + [1534] = 1416, + [1535] = 1426, + [1536] = 1389, + [1537] = 1435, + [1538] = 705, + [1539] = 1422, + [1540] = 680, + [1541] = 1382, [1542] = 1542, [1543] = 1543, - [1544] = 1544, - [1545] = 709, + [1544] = 1465, + [1545] = 1545, [1546] = 1546, - [1547] = 710, - [1548] = 1548, - [1549] = 1549, - [1550] = 1413, - [1551] = 711, - [1552] = 1552, - [1553] = 756, + [1547] = 1465, + [1548] = 1402, + [1549] = 1465, + [1550] = 1465, + [1551] = 1465, + [1552] = 1384, + [1553] = 1553, [1554] = 1554, - [1555] = 1555, - [1556] = 712, - [1557] = 1546, - [1558] = 270, - [1559] = 1487, + [1555] = 1390, + [1556] = 1556, + [1557] = 717, + [1558] = 1437, + [1559] = 658, [1560] = 1560, - [1561] = 689, + [1561] = 1561, [1562] = 1562, - [1563] = 713, - [1564] = 1362, - [1565] = 1565, - [1566] = 1419, - [1567] = 1455, - [1568] = 1562, - [1569] = 1569, + [1563] = 1563, + [1564] = 1560, + [1565] = 718, + [1566] = 728, + [1567] = 1391, + [1568] = 1568, + [1569] = 1453, [1570] = 1570, - [1571] = 1383, - [1572] = 1391, - [1573] = 1421, - [1574] = 714, - [1575] = 1422, - [1576] = 1576, - [1577] = 1577, - [1578] = 1491, - [1579] = 716, - [1580] = 677, - [1581] = 690, - [1582] = 1565, - [1583] = 1583, - [1584] = 1374, - [1585] = 1392, - [1586] = 1438, + [1571] = 729, + [1572] = 1572, + [1573] = 1573, + [1574] = 1574, + [1575] = 1575, + [1576] = 1542, + [1577] = 1561, + [1578] = 730, + [1579] = 1476, + [1580] = 1580, + [1581] = 1517, + [1582] = 1582, + [1583] = 731, + [1584] = 732, + [1585] = 681, + [1586] = 1586, [1587] = 1587, - [1588] = 1588, + [1588] = 682, [1589] = 1589, - [1590] = 1590, + [1590] = 1492, [1591] = 1591, - [1592] = 1377, - [1593] = 670, + [1592] = 1575, + [1593] = 735, [1594] = 1594, - [1595] = 1393, - [1596] = 678, - [1597] = 1474, - [1598] = 708, - [1599] = 1599, - [1600] = 1501, - [1601] = 1601, - [1602] = 1602, - [1603] = 1603, - [1604] = 1395, - [1605] = 1605, + [1595] = 1431, + [1596] = 1596, + [1597] = 1432, + [1598] = 1598, + [1599] = 1462, + [1600] = 1467, + [1601] = 733, + [1602] = 1370, + [1603] = 736, + [1604] = 1572, + [1605] = 1501, [1606] = 1606, - [1607] = 1371, - [1608] = 1442, + [1607] = 1607, + [1608] = 1608, [1609] = 1609, - [1610] = 1467, - [1611] = 1470, - [1612] = 1480, - [1613] = 1613, - [1614] = 664, - [1615] = 1615, - [1616] = 1594, - [1617] = 1617, - [1618] = 1403, - [1619] = 1427, - [1620] = 1620, - [1621] = 1621, - [1622] = 1622, - [1623] = 1543, - [1624] = 1624, - [1625] = 1624, - [1626] = 1626, - [1627] = 1627, - [1628] = 719, - [1629] = 1629, - [1630] = 1630, - [1631] = 1631, - [1632] = 1546, - [1633] = 1548, - [1634] = 1413, - [1635] = 720, - [1636] = 721, - [1637] = 1637, - [1638] = 1638, + [1610] = 1610, + [1611] = 1611, + [1612] = 1506, + [1613] = 669, + [1614] = 1614, + [1615] = 1563, + [1616] = 1589, + [1617] = 1385, + [1618] = 1440, + [1619] = 1596, + [1620] = 1480, + [1621] = 1484, + [1622] = 1494, + [1623] = 1623, + [1624] = 737, + [1625] = 1492, + [1626] = 1614, + [1627] = 1392, + [1628] = 1398, + [1629] = 1469, + [1630] = 1496, + [1631] = 738, + [1632] = 1632, + [1633] = 1424, + [1634] = 1634, + [1635] = 1487, + [1636] = 1636, + [1637] = 739, + [1638] = 683, [1639] = 1639, - [1640] = 679, - [1641] = 1641, - [1642] = 1562, - [1643] = 723, - [1644] = 1362, + [1640] = 1640, + [1641] = 741, + [1642] = 1556, + [1643] = 1643, + [1644] = 1560, [1645] = 1645, - [1646] = 1569, + [1646] = 742, [1647] = 1647, [1648] = 1648, - [1649] = 724, - [1650] = 665, - [1651] = 1651, - [1652] = 1652, - [1653] = 725, - [1654] = 1605, - [1655] = 1589, - [1656] = 1656, - [1657] = 1377, - [1658] = 1589, - [1659] = 1659, - [1660] = 1606, - [1661] = 1606, - [1662] = 1371, - [1663] = 1442, - [1664] = 726, - [1665] = 1665, + [1649] = 1649, + [1650] = 1650, + [1651] = 757, + [1652] = 1572, + [1653] = 1607, + [1654] = 1574, + [1655] = 1556, + [1656] = 1476, + [1657] = 1657, + [1658] = 743, + [1659] = 1465, + [1660] = 1660, + [1661] = 1661, + [1662] = 1662, + [1663] = 744, + [1664] = 1501, + [1665] = 1462, [1666] = 1666, - [1667] = 1555, - [1668] = 1668, - [1669] = 680, - [1670] = 1656, - [1671] = 1549, - [1672] = 1672, - [1673] = 1626, - [1674] = 1590, - [1675] = 1548, - [1676] = 1676, - [1677] = 1468, - [1678] = 757, - [1679] = 1425, - [1680] = 1554, - [1681] = 1457, + [1667] = 1370, + [1668] = 1376, + [1669] = 1669, + [1670] = 284, + [1671] = 1589, + [1672] = 1385, + [1673] = 1440, + [1674] = 745, + [1675] = 1675, + [1676] = 1447, + [1677] = 1573, + [1678] = 1610, + [1679] = 1679, + [1680] = 1381, + [1681] = 1481, [1682] = 1682, - [1683] = 1471, - [1684] = 692, - [1685] = 693, - [1686] = 1641, - [1687] = 1385, - [1688] = 1477, - [1689] = 1533, - [1690] = 1552, - [1691] = 1676, - [1692] = 1485, - [1693] = 1482, - [1694] = 1659, - [1695] = 1454, - [1696] = 1366, - [1697] = 1535, - [1698] = 1622, - [1699] = 1478, - [1700] = 1373, - [1701] = 1399, - [1702] = 1702, - [1703] = 1569, - [1704] = 1656, - [1705] = 1549, - [1706] = 1666, - [1707] = 1554, - [1708] = 1409, - [1709] = 1641, - [1710] = 1385, - [1711] = 842, - [1712] = 1659, - [1713] = 1454, - [1714] = 1602, - [1715] = 1479, - [1716] = 1587, - [1717] = 728, - [1718] = 694, - [1719] = 1490, - [1720] = 1453, - [1721] = 1456, - [1722] = 1466, - [1723] = 1491, - [1724] = 1577, - [1725] = 1648, - [1726] = 1726, - [1727] = 1365, - [1728] = 729, - [1729] = 1542, - [1730] = 1465, - [1731] = 759, - [1732] = 1451, - [1733] = 730, - [1734] = 1734, - [1735] = 731, - [1736] = 1648, - [1737] = 1360, - [1738] = 1530, - [1739] = 732, - [1740] = 682, + [1683] = 1679, + [1684] = 1684, + [1685] = 1437, + [1686] = 1466, + [1687] = 1647, + [1688] = 1587, + [1689] = 1506, + [1690] = 1485, + [1691] = 1418, + [1692] = 1692, + [1693] = 1553, + [1694] = 1694, + [1695] = 1695, + [1696] = 1582, + [1697] = 1380, + [1698] = 1698, + [1699] = 1546, + [1700] = 1554, + [1701] = 1442, + [1702] = 1591, + [1703] = 689, + [1704] = 1464, + [1705] = 1598, + [1706] = 1706, + [1707] = 1707, + [1708] = 1463, + [1709] = 1491, + [1710] = 1543, + [1711] = 1395, + [1712] = 1712, + [1713] = 747, + [1714] = 1381, + [1715] = 1481, + [1716] = 673, + [1717] = 1485, + [1718] = 1574, + [1719] = 1582, + [1720] = 1380, + [1721] = 1721, + [1722] = 1464, + [1723] = 1598, + [1724] = 1404, + [1725] = 1725, + [1726] = 1657, + [1727] = 1727, + [1728] = 1435, + [1729] = 1396, + [1730] = 1504, + [1731] = 1682, + [1732] = 1459, + [1733] = 750, + [1734] = 752, + [1735] = 1608, + [1736] = 1451, + [1737] = 1737, + [1738] = 748, + [1739] = 1739, + [1740] = 1478, [1741] = 1741, - [1742] = 683, + [1742] = 258, [1743] = 1743, - [1744] = 1530, + [1744] = 1737, [1745] = 1745, - [1746] = 735, - [1747] = 1370, - [1748] = 1426, - [1749] = 1428, - [1750] = 715, + [1746] = 1608, + [1747] = 1451, + [1748] = 1452, + [1749] = 872, + [1750] = 755, + [1751] = 1751, + [1752] = 1707, + [1753] = 1753, + [1754] = 1452, + [1755] = 1372, + [1756] = 1399, + [1757] = 1757, + [1758] = 1725, + [1759] = 1594, + [1760] = 1379, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -5041,21 +5089,22 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { ADVANCE_MAP( '_', 1, 'a', 2, - 'e', 3, - 'f', 4, - 'h', 5, - 'i', 6, - 'k', 7, - 'l', 8, - 'm', 9, - 'n', 10, - 'o', 11, - 'p', 12, - 'r', 13, - 's', 14, - 't', 15, - 'w', 16, - 'y', 17, + 'd', 3, + 'e', 4, + 'f', 5, + 'h', 6, + 'i', 7, + 'k', 8, + 'l', 9, + 'm', 10, + 'n', 11, + 'o', 12, + 'p', 13, + 'r', 14, + 's', 15, + 't', 16, + 'w', 17, + 'y', 18, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(0); @@ -5064,502 +5113,508 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { ACCEPT_TOKEN(anon_sym__); END_STATE(); case 2: - if (lookahead == 'b') ADVANCE(18); - if (lookahead == 's') ADVANCE(19); - if (lookahead == 'w') ADVANCE(20); + if (lookahead == 'b') ADVANCE(19); + if (lookahead == 's') ADVANCE(20); + if (lookahead == 'w') ADVANCE(21); END_STATE(); case 3: - if (lookahead == 'f') ADVANCE(21); - if (lookahead == 'l') ADVANCE(22); - if (lookahead == 'x') ADVANCE(23); + if (lookahead == 'o') ADVANCE(22); END_STATE(); case 4: - if (lookahead == 'a') ADVANCE(24); - if (lookahead == 'n') ADVANCE(25); + if (lookahead == 'f') ADVANCE(23); + if (lookahead == 'l') ADVANCE(24); + if (lookahead == 'x') ADVANCE(25); END_STATE(); case 5: if (lookahead == 'a') ADVANCE(26); + if (lookahead == 'n') ADVANCE(27); END_STATE(); case 6: - if (lookahead == 'f') ADVANCE(27); - if (lookahead == 'm') ADVANCE(28); - if (lookahead == 'n') ADVANCE(29); + if (lookahead == 'a') ADVANCE(28); END_STATE(); case 7: - if (lookahead == 'e') ADVANCE(30); + if (lookahead == 'f') ADVANCE(29); + if (lookahead == 'm') ADVANCE(30); + if (lookahead == 'n') ADVANCE(31); END_STATE(); case 8: - if (lookahead == 'e') ADVANCE(31); + if (lookahead == 'e') ADVANCE(32); END_STATE(); case 9: - if (lookahead == 'a') ADVANCE(32); - if (lookahead == 'o') ADVANCE(33); - if (lookahead == 'u') ADVANCE(34); + if (lookahead == 'e') ADVANCE(33); END_STATE(); case 10: - if (lookahead == 'a') ADVANCE(35); + if (lookahead == 'a') ADVANCE(34); + if (lookahead == 'o') ADVANCE(35); + if (lookahead == 'u') ADVANCE(36); END_STATE(); case 11: - if (lookahead == 'n') ADVANCE(36); - if (lookahead == 'p') ADVANCE(37); - if (lookahead == 'u') ADVANCE(38); + if (lookahead == 'a') ADVANCE(37); END_STATE(); case 12: - if (lookahead == 'e') ADVANCE(39); + if (lookahead == 'n') ADVANCE(38); + if (lookahead == 'p') ADVANCE(39); + if (lookahead == 'u') ADVANCE(40); END_STATE(); case 13: - if (lookahead == 'e') ADVANCE(40); + if (lookahead == 'e') ADVANCE(41); END_STATE(); case 14: - if (lookahead == 'e') ADVANCE(41); - if (lookahead == 'i') ADVANCE(42); - if (lookahead == 'p') ADVANCE(43); - if (lookahead == 't') ADVANCE(44); + if (lookahead == 'e') ADVANCE(42); END_STATE(); case 15: - if (lookahead == 'r') ADVANCE(45); - if (lookahead == 'y') ADVANCE(46); + if (lookahead == 'e') ADVANCE(43); + if (lookahead == 'i') ADVANCE(44); + if (lookahead == 'p') ADVANCE(45); + if (lookahead == 't') ADVANCE(46); END_STATE(); case 16: - if (lookahead == 'h') ADVANCE(47); + if (lookahead == 'r') ADVANCE(47); + if (lookahead == 'y') ADVANCE(48); END_STATE(); case 17: - if (lookahead == 'i') ADVANCE(48); + if (lookahead == 'h') ADVANCE(49); END_STATE(); case 18: - if (lookahead == 'o') ADVANCE(49); + if (lookahead == 'i') ADVANCE(50); END_STATE(); case 19: - ACCEPT_TOKEN(anon_sym_as); + if (lookahead == 'o') ADVANCE(51); END_STATE(); case 20: - if (lookahead == 'a') ADVANCE(50); + ACCEPT_TOKEN(anon_sym_as); END_STATE(); case 21: - if (lookahead == 'f') ADVANCE(51); + if (lookahead == 'a') ADVANCE(52); END_STATE(); case 22: - if (lookahead == 's') ADVANCE(52); + ACCEPT_TOKEN(anon_sym_do); END_STATE(); case 23: - if (lookahead == 'p') ADVANCE(53); - if (lookahead == 't') ADVANCE(54); + if (lookahead == 'f') ADVANCE(53); END_STATE(); case 24: - if (lookahead == 'l') ADVANCE(55); + if (lookahead == 's') ADVANCE(54); END_STATE(); case 25: - ACCEPT_TOKEN(anon_sym_fn); + if (lookahead == 'p') ADVANCE(55); + if (lookahead == 't') ADVANCE(56); END_STATE(); case 26: - if (lookahead == 'n') ADVANCE(56); + if (lookahead == 'l') ADVANCE(57); END_STATE(); case 27: - ACCEPT_TOKEN(anon_sym_if); + ACCEPT_TOKEN(anon_sym_fn); END_STATE(); case 28: - if (lookahead == 'p') ADVANCE(57); + if (lookahead == 'n') ADVANCE(58); END_STATE(); case 29: - ACCEPT_TOKEN(anon_sym_in); + ACCEPT_TOKEN(anon_sym_if); END_STATE(); case 30: - if (lookahead == 'r') ADVANCE(58); + if (lookahead == 'p') ADVANCE(59); END_STATE(); case 31: - if (lookahead == 't') ADVANCE(59); + ACCEPT_TOKEN(anon_sym_in); END_STATE(); case 32: - if (lookahead == 'n') ADVANCE(60); - if (lookahead == 't') ADVANCE(61); + if (lookahead == 'r') ADVANCE(60); END_STATE(); case 33: - if (lookahead == 'd') ADVANCE(62); + if (lookahead == 't') ADVANCE(61); END_STATE(); case 34: + if (lookahead == 'n') ADVANCE(62); if (lookahead == 't') ADVANCE(63); END_STATE(); case 35: - if (lookahead == 'm') ADVANCE(64); + if (lookahead == 'd') ADVANCE(64); END_STATE(); case 36: - if (lookahead == 'c') ADVANCE(65); + if (lookahead == 't') ADVANCE(65); END_STATE(); case 37: - if (lookahead == 'a') ADVANCE(66); + if (lookahead == 'm') ADVANCE(66); END_STATE(); case 38: - if (lookahead == 't') ADVANCE(67); + if (lookahead == 'c') ADVANCE(67); END_STATE(); case 39: - if (lookahead == 'r') ADVANCE(68); + if (lookahead == 'a') ADVANCE(68); END_STATE(); case 40: - if (lookahead == 'c') ADVANCE(69); - if (lookahead == 'p') ADVANCE(70); - if (lookahead == 's') ADVANCE(71); + if (lookahead == 't') ADVANCE(69); END_STATE(); case 41: - if (lookahead == 'l') ADVANCE(72); - if (lookahead == 'n') ADVANCE(73); + if (lookahead == 'r') ADVANCE(70); END_STATE(); case 42: - if (lookahead == 'g') ADVANCE(74); + if (lookahead == 'c') ADVANCE(71); + if (lookahead == 'p') ADVANCE(72); + if (lookahead == 's') ADVANCE(73); END_STATE(); case 43: - if (lookahead == 'a') ADVANCE(75); + if (lookahead == 'l') ADVANCE(74); + if (lookahead == 'n') ADVANCE(75); END_STATE(); case 44: - if (lookahead == 'a') ADVANCE(76); + if (lookahead == 'g') ADVANCE(76); END_STATE(); case 45: - if (lookahead == 'u') ADVANCE(77); + if (lookahead == 'a') ADVANCE(77); END_STATE(); case 46: - if (lookahead == 'p') ADVANCE(78); + if (lookahead == 'a') ADVANCE(78); END_STATE(); case 47: - if (lookahead == 'e') ADVANCE(79); + if (lookahead == 'u') ADVANCE(79); END_STATE(); case 48: - if (lookahead == 'e') ADVANCE(80); + if (lookahead == 'p') ADVANCE(80); END_STATE(); case 49: - if (lookahead == 'r') ADVANCE(81); + if (lookahead == 'e') ADVANCE(81); END_STATE(); case 50: - if (lookahead == 'i') ADVANCE(82); + if (lookahead == 'e') ADVANCE(82); END_STATE(); case 51: - if (lookahead == 'e') ADVANCE(83); + if (lookahead == 'r') ADVANCE(83); END_STATE(); case 52: - if (lookahead == 'e') ADVANCE(84); + if (lookahead == 'i') ADVANCE(84); END_STATE(); case 53: - if (lookahead == 'o') ADVANCE(85); + if (lookahead == 'e') ADVANCE(85); END_STATE(); case 54: if (lookahead == 'e') ADVANCE(86); - if (lookahead == 'r') ADVANCE(87); END_STATE(); case 55: - if (lookahead == 's') ADVANCE(88); + if (lookahead == 'o') ADVANCE(87); END_STATE(); case 56: - if (lookahead == 'd') ADVANCE(89); + if (lookahead == 'e') ADVANCE(88); + if (lookahead == 'r') ADVANCE(89); END_STATE(); case 57: - if (lookahead == 'o') ADVANCE(90); + if (lookahead == 's') ADVANCE(90); END_STATE(); case 58: - if (lookahead == 'n') ADVANCE(91); + if (lookahead == 'd') ADVANCE(91); END_STATE(); case 59: - ACCEPT_TOKEN(anon_sym_let); + if (lookahead == 'o') ADVANCE(92); END_STATE(); case 60: - if (lookahead == 'y') ADVANCE(92); + if (lookahead == 'n') ADVANCE(93); END_STATE(); case 61: - if (lookahead == 'c') ADVANCE(93); + ACCEPT_TOKEN(anon_sym_let); END_STATE(); case 62: - if (lookahead == 'u') ADVANCE(94); + if (lookahead == 'y') ADVANCE(94); END_STATE(); case 63: - ACCEPT_TOKEN(anon_sym_mut); + if (lookahead == 'c') ADVANCE(95); END_STATE(); case 64: - if (lookahead == 'e') ADVANCE(95); + if (lookahead == 'u') ADVANCE(96); END_STATE(); case 65: - if (lookahead == 'e') ADVANCE(96); + ACCEPT_TOKEN(anon_sym_mut); END_STATE(); case 66: - if (lookahead == 'q') ADVANCE(97); + if (lookahead == 'e') ADVANCE(97); END_STATE(); case 67: - ACCEPT_TOKEN(anon_sym_out); + if (lookahead == 'e') ADVANCE(98); END_STATE(); case 68: - if (lookahead == 'f') ADVANCE(98); + if (lookahead == 'q') ADVANCE(99); END_STATE(); case 69: - if (lookahead == 'v') ADVANCE(99); + ACCEPT_TOKEN(anon_sym_out); END_STATE(); case 70: - if (lookahead == 'l') ADVANCE(100); + if (lookahead == 'f') ADVANCE(100); END_STATE(); case 71: - if (lookahead == 'u') ADVANCE(101); + if (lookahead == 'v') ADVANCE(101); END_STATE(); case 72: - if (lookahead == 'e') ADVANCE(102); + if (lookahead == 'l') ADVANCE(102); END_STATE(); case 73: - if (lookahead == 'd') ADVANCE(103); + if (lookahead == 'u') ADVANCE(103); END_STATE(); case 74: - if (lookahead == 'n') ADVANCE(104); + if (lookahead == 'e') ADVANCE(104); END_STATE(); case 75: - if (lookahead == 'w') ADVANCE(105); + if (lookahead == 'd') ADVANCE(105); END_STATE(); case 76: - if (lookahead == 't') ADVANCE(106); + if (lookahead == 'n') ADVANCE(106); END_STATE(); case 77: - if (lookahead == 'e') ADVANCE(107); + if (lookahead == 'w') ADVANCE(107); END_STATE(); case 78: - if (lookahead == 'e') ADVANCE(108); + if (lookahead == 't') ADVANCE(108); END_STATE(); case 79: - if (lookahead == 'r') ADVANCE(109); + if (lookahead == 'e') ADVANCE(109); END_STATE(); case 80: - if (lookahead == 'l') ADVANCE(110); + if (lookahead == 'e') ADVANCE(110); END_STATE(); case 81: - if (lookahead == 't') ADVANCE(111); + if (lookahead == 'r') ADVANCE(111); END_STATE(); case 82: - if (lookahead == 't') ADVANCE(112); + if (lookahead == 'l') ADVANCE(112); END_STATE(); case 83: - if (lookahead == 'c') ADVANCE(113); + if (lookahead == 't') ADVANCE(113); END_STATE(); case 84: - ACCEPT_TOKEN(anon_sym_else); + if (lookahead == 't') ADVANCE(114); END_STATE(); case 85: - if (lookahead == 'r') ADVANCE(114); + if (lookahead == 'c') ADVANCE(115); END_STATE(); case 86: - if (lookahead == 'r') ADVANCE(115); + ACCEPT_TOKEN(anon_sym_else); END_STATE(); case 87: - if (lookahead == 'a') ADVANCE(116); + if (lookahead == 'r') ADVANCE(116); END_STATE(); case 88: - if (lookahead == 'e') ADVANCE(117); + if (lookahead == 'r') ADVANCE(117); END_STATE(); case 89: - if (lookahead == 'l') ADVANCE(118); + if (lookahead == 'a') ADVANCE(118); END_STATE(); case 90: - if (lookahead == 'r') ADVANCE(119); + if (lookahead == 'e') ADVANCE(119); END_STATE(); case 91: - if (lookahead == 'e') ADVANCE(120); + if (lookahead == 'l') ADVANCE(120); END_STATE(); case 92: - ACCEPT_TOKEN(anon_sym_many); + if (lookahead == 'r') ADVANCE(121); END_STATE(); case 93: - if (lookahead == 'h') ADVANCE(121); + if (lookahead == 'e') ADVANCE(122); END_STATE(); case 94: - if (lookahead == 'l') ADVANCE(122); + ACCEPT_TOKEN(anon_sym_many); END_STATE(); case 95: - if (lookahead == 's') ADVANCE(123); + if (lookahead == 'h') ADVANCE(123); END_STATE(); case 96: - ACCEPT_TOKEN(anon_sym_once); + if (lookahead == 'l') ADVANCE(124); END_STATE(); case 97: - if (lookahead == 'u') ADVANCE(124); + if (lookahead == 's') ADVANCE(125); END_STATE(); case 98: - if (lookahead == 'o') ADVANCE(125); + ACCEPT_TOKEN(anon_sym_once); END_STATE(); case 99: - ACCEPT_TOKEN(anon_sym_recv); + if (lookahead == 'u') ADVANCE(126); END_STATE(); case 100: - if (lookahead == 'a') ADVANCE(126); + if (lookahead == 'o') ADVANCE(127); END_STATE(); case 101: - if (lookahead == 'm') ADVANCE(127); + ACCEPT_TOKEN(anon_sym_recv); END_STATE(); case 102: - if (lookahead == 'c') ADVANCE(128); + if (lookahead == 'a') ADVANCE(128); END_STATE(); case 103: - ACCEPT_TOKEN(anon_sym_send); + if (lookahead == 'm') ADVANCE(129); END_STATE(); case 104: - if (lookahead == 'a') ADVANCE(129); + if (lookahead == 'c') ADVANCE(130); END_STATE(); case 105: - if (lookahead == 'n') ADVANCE(130); + ACCEPT_TOKEN(anon_sym_send); END_STATE(); case 106: - if (lookahead == 'e') ADVANCE(131); - if (lookahead == 'i') ADVANCE(132); + if (lookahead == 'a') ADVANCE(131); END_STATE(); case 107: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 'n') ADVANCE(132); END_STATE(); case 108: - ACCEPT_TOKEN(anon_sym_type); + if (lookahead == 'e') ADVANCE(133); + if (lookahead == 'i') ADVANCE(134); END_STATE(); case 109: - if (lookahead == 'e') ADVANCE(133); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 110: - if (lookahead == 'd') ADVANCE(134); + ACCEPT_TOKEN(anon_sym_type); END_STATE(); case 111: - ACCEPT_TOKEN(anon_sym_abort); + if (lookahead == 'e') ADVANCE(135); END_STATE(); case 112: - ACCEPT_TOKEN(anon_sym_await); + if (lookahead == 'd') ADVANCE(136); END_STATE(); case 113: - if (lookahead == 't') ADVANCE(135); + ACCEPT_TOKEN(anon_sym_abort); END_STATE(); case 114: - if (lookahead == 't') ADVANCE(136); + ACCEPT_TOKEN(anon_sym_await); END_STATE(); case 115: - if (lookahead == 'n') ADVANCE(137); + if (lookahead == 't') ADVANCE(137); END_STATE(); case 116: - ACCEPT_TOKEN(anon_sym_extra); + if (lookahead == 't') ADVANCE(138); END_STATE(); case 117: - ACCEPT_TOKEN(anon_sym_false); + if (lookahead == 'n') ADVANCE(139); END_STATE(); case 118: - if (lookahead == 'e') ADVANCE(138); + ACCEPT_TOKEN(anon_sym_extra); END_STATE(); case 119: - if (lookahead == 't') ADVANCE(139); + ACCEPT_TOKEN(anon_sym_false); END_STATE(); case 120: - if (lookahead == 'l') ADVANCE(140); + if (lookahead == 'e') ADVANCE(140); END_STATE(); case 121: - ACCEPT_TOKEN(anon_sym_match); + if (lookahead == 't') ADVANCE(141); END_STATE(); case 122: - if (lookahead == 'e') ADVANCE(141); + if (lookahead == 'l') ADVANCE(142); END_STATE(); case 123: - if (lookahead == 'p') ADVANCE(142); + ACCEPT_TOKEN(anon_sym_match); END_STATE(); case 124: if (lookahead == 'e') ADVANCE(143); END_STATE(); case 125: - if (lookahead == 'r') ADVANCE(144); + if (lookahead == 'p') ADVANCE(144); END_STATE(); case 126: - if (lookahead == 'y') ADVANCE(145); + if (lookahead == 'e') ADVANCE(145); END_STATE(); case 127: - if (lookahead == 'e') ADVANCE(146); + if (lookahead == 'r') ADVANCE(146); END_STATE(); case 128: - if (lookahead == 't') ADVANCE(147); + if (lookahead == 'y') ADVANCE(147); END_STATE(); case 129: - if (lookahead == 't') ADVANCE(148); + if (lookahead == 'e') ADVANCE(148); END_STATE(); case 130: - ACCEPT_TOKEN(anon_sym_spawn); + if (lookahead == 't') ADVANCE(149); END_STATE(); case 131: - ACCEPT_TOKEN(anon_sym_state); + if (lookahead == 't') ADVANCE(150); END_STATE(); case 132: - if (lookahead == 'c') ADVANCE(149); + ACCEPT_TOKEN(anon_sym_spawn); END_STATE(); case 133: - ACCEPT_TOKEN(anon_sym_where); + ACCEPT_TOKEN(anon_sym_state); END_STATE(); case 134: - ACCEPT_TOKEN(anon_sym_yield); + if (lookahead == 'c') ADVANCE(151); END_STATE(); case 135: - ACCEPT_TOKEN(anon_sym_effect); + ACCEPT_TOKEN(anon_sym_where); END_STATE(); case 136: - ACCEPT_TOKEN(anon_sym_export); + ACCEPT_TOKEN(anon_sym_yield); END_STATE(); case 137: - ACCEPT_TOKEN(anon_sym_extern); + ACCEPT_TOKEN(anon_sym_effect); END_STATE(); case 138: - ACCEPT_TOKEN(anon_sym_handle); + ACCEPT_TOKEN(anon_sym_export); END_STATE(); case 139: - ACCEPT_TOKEN(anon_sym_import); + ACCEPT_TOKEN(anon_sym_extern); END_STATE(); case 140: - ACCEPT_TOKEN(anon_sym_kernel); + ACCEPT_TOKEN(anon_sym_handle); END_STATE(); case 141: - ACCEPT_TOKEN(anon_sym_module); + ACCEPT_TOKEN(anon_sym_import); END_STATE(); case 142: - if (lookahead == 'a') ADVANCE(150); + ACCEPT_TOKEN(anon_sym_kernel); END_STATE(); case 143: - ACCEPT_TOKEN(anon_sym_opaque); + ACCEPT_TOKEN(anon_sym_module); END_STATE(); case 144: - if (lookahead == 'm') ADVANCE(151); + if (lookahead == 'a') ADVANCE(152); END_STATE(); case 145: - if (lookahead == 'a') ADVANCE(152); + ACCEPT_TOKEN(anon_sym_opaque); END_STATE(); case 146: - ACCEPT_TOKEN(anon_sym_resume); + if (lookahead == 'm') ADVANCE(153); END_STATE(); case 147: - ACCEPT_TOKEN(anon_sym_select); + if (lookahead == 'a') ADVANCE(154); END_STATE(); case 148: - if (lookahead == 'u') ADVANCE(153); + ACCEPT_TOKEN(anon_sym_resume); END_STATE(); case 149: - ACCEPT_TOKEN(sym_static_stage); + ACCEPT_TOKEN(anon_sym_select); END_STATE(); case 150: - if (lookahead == 'c') ADVANCE(154); + if (lookahead == 'u') ADVANCE(155); END_STATE(); case 151: - ACCEPT_TOKEN(anon_sym_perform); + ACCEPT_TOKEN(sym_static_stage); END_STATE(); case 152: - if (lookahead == 'b') ADVANCE(155); + if (lookahead == 'c') ADVANCE(156); END_STATE(); case 153: - if (lookahead == 'r') ADVANCE(156); + ACCEPT_TOKEN(anon_sym_perform); END_STATE(); case 154: - if (lookahead == 'e') ADVANCE(157); + if (lookahead == 'b') ADVANCE(157); END_STATE(); case 155: - if (lookahead == 'l') ADVANCE(158); + if (lookahead == 'r') ADVANCE(158); END_STATE(); case 156: if (lookahead == 'e') ADVANCE(159); END_STATE(); case 157: - ACCEPT_TOKEN(anon_sym_namespace); + if (lookahead == 'l') ADVANCE(160); END_STATE(); case 158: - if (lookahead == 'e') ADVANCE(160); + if (lookahead == 'e') ADVANCE(161); END_STATE(); case 159: - ACCEPT_TOKEN(anon_sym_signature); + ACCEPT_TOKEN(anon_sym_namespace); END_STATE(); case 160: + if (lookahead == 'e') ADVANCE(162); + END_STATE(); + case 161: + ACCEPT_TOKEN(anon_sym_signature); + END_STATE(); + case 162: ACCEPT_TOKEN(sym_replayable); END_STATE(); default: @@ -5796,9 +5851,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [225] = {.lex_state = 8}, [226] = {.lex_state = 43}, [227] = {.lex_state = 43}, - [228] = {.lex_state = 43}, + [228] = {.lex_state = 41, .external_lex_state = 2}, [229] = {.lex_state = 43}, - [230] = {.lex_state = 41, .external_lex_state = 2}, + [230] = {.lex_state = 43}, [231] = {.lex_state = 41, .external_lex_state = 2}, [232] = {.lex_state = 41, .external_lex_state = 2}, [233] = {.lex_state = 41, .external_lex_state = 2}, @@ -5860,9 +5915,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [289] = {.lex_state = 41, .external_lex_state = 2}, [290] = {.lex_state = 41, .external_lex_state = 2}, [291] = {.lex_state = 41, .external_lex_state = 2}, - [292] = {.lex_state = 6, .external_lex_state = 2}, + [292] = {.lex_state = 41, .external_lex_state = 2}, [293] = {.lex_state = 41, .external_lex_state = 2}, - [294] = {.lex_state = 41, .external_lex_state = 2}, + [294] = {.lex_state = 6, .external_lex_state = 2}, [295] = {.lex_state = 6, .external_lex_state = 2}, [296] = {.lex_state = 6, .external_lex_state = 2}, [297] = {.lex_state = 6, .external_lex_state = 2}, @@ -5971,18 +6026,18 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [400] = {.lex_state = 0}, [401] = {.lex_state = 0}, [402] = {.lex_state = 0}, - [403] = {.lex_state = 41, .external_lex_state = 1}, + [403] = {.lex_state = 0}, [404] = {.lex_state = 0}, - [405] = {.lex_state = 0}, - [406] = {.lex_state = 0}, - [407] = {.lex_state = 0}, - [408] = {.lex_state = 0}, - [409] = {.lex_state = 41, .external_lex_state = 2}, - [410] = {.lex_state = 41, .external_lex_state = 1}, + [405] = {.lex_state = 41, .external_lex_state = 2}, + [406] = {.lex_state = 41, .external_lex_state = 1}, + [407] = {.lex_state = 41, .external_lex_state = 2}, + [408] = {.lex_state = 41, .external_lex_state = 1}, + [409] = {.lex_state = 0}, + [410] = {.lex_state = 0}, [411] = {.lex_state = 0}, [412] = {.lex_state = 0}, [413] = {.lex_state = 0}, - [414] = {.lex_state = 41, .external_lex_state = 2}, + [414] = {.lex_state = 0}, [415] = {.lex_state = 0}, [416] = {.lex_state = 0}, [417] = {.lex_state = 0}, @@ -6005,24 +6060,24 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [434] = {.lex_state = 0}, [435] = {.lex_state = 0}, [436] = {.lex_state = 0}, - [437] = {.lex_state = 41, .external_lex_state = 1}, + [437] = {.lex_state = 43}, [438] = {.lex_state = 41, .external_lex_state = 1}, - [439] = {.lex_state = 43}, + [439] = {.lex_state = 41, .external_lex_state = 1}, [440] = {.lex_state = 41, .external_lex_state = 1}, - [441] = {.lex_state = 41, .external_lex_state = 1}, + [441] = {.lex_state = 41, .external_lex_state = 2}, [442] = {.lex_state = 41, .external_lex_state = 1}, [443] = {.lex_state = 41, .external_lex_state = 1}, - [444] = {.lex_state = 41, .external_lex_state = 2}, + [444] = {.lex_state = 41, .external_lex_state = 1}, [445] = {.lex_state = 41, .external_lex_state = 1}, [446] = {.lex_state = 41, .external_lex_state = 1}, [447] = {.lex_state = 41, .external_lex_state = 1}, - [448] = {.lex_state = 41, .external_lex_state = 2}, + [448] = {.lex_state = 41, .external_lex_state = 1}, [449] = {.lex_state = 41, .external_lex_state = 1}, [450] = {.lex_state = 41, .external_lex_state = 1}, [451] = {.lex_state = 41, .external_lex_state = 1}, [452] = {.lex_state = 41, .external_lex_state = 1}, - [453] = {.lex_state = 41, .external_lex_state = 1}, - [454] = {.lex_state = 41, .external_lex_state = 1}, + [453] = {.lex_state = 41, .external_lex_state = 2}, + [454] = {.lex_state = 41, .external_lex_state = 2}, [455] = {.lex_state = 41, .external_lex_state = 1}, [456] = {.lex_state = 41, .external_lex_state = 1}, [457] = {.lex_state = 41, .external_lex_state = 2}, @@ -6031,26 +6086,26 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [460] = {.lex_state = 41, .external_lex_state = 1}, [461] = {.lex_state = 41, .external_lex_state = 1}, [462] = {.lex_state = 41, .external_lex_state = 1}, - [463] = {.lex_state = 41, .external_lex_state = 1}, - [464] = {.lex_state = 41, .external_lex_state = 2}, + [463] = {.lex_state = 41, .external_lex_state = 2}, + [464] = {.lex_state = 41, .external_lex_state = 1}, [465] = {.lex_state = 41, .external_lex_state = 1}, [466] = {.lex_state = 41, .external_lex_state = 1}, - [467] = {.lex_state = 41, .external_lex_state = 2}, + [467] = {.lex_state = 41, .external_lex_state = 1}, [468] = {.lex_state = 41, .external_lex_state = 1}, - [469] = {.lex_state = 41, .external_lex_state = 1}, + [469] = {.lex_state = 41, .external_lex_state = 2}, [470] = {.lex_state = 41, .external_lex_state = 1}, [471] = {.lex_state = 41, .external_lex_state = 1}, - [472] = {.lex_state = 41, .external_lex_state = 2}, - [473] = {.lex_state = 41, .external_lex_state = 1}, + [472] = {.lex_state = 41, .external_lex_state = 1}, + [473] = {.lex_state = 41, .external_lex_state = 2}, [474] = {.lex_state = 41, .external_lex_state = 1}, [475] = {.lex_state = 41, .external_lex_state = 1}, [476] = {.lex_state = 41, .external_lex_state = 1}, - [477] = {.lex_state = 41, .external_lex_state = 1}, + [477] = {.lex_state = 41, .external_lex_state = 2}, [478] = {.lex_state = 41, .external_lex_state = 1}, [479] = {.lex_state = 41, .external_lex_state = 1}, - [480] = {.lex_state = 41, .external_lex_state = 1}, + [480] = {.lex_state = 41, .external_lex_state = 2}, [481] = {.lex_state = 41, .external_lex_state = 1}, - [482] = {.lex_state = 41, .external_lex_state = 1}, + [482] = {.lex_state = 8}, [483] = {.lex_state = 41, .external_lex_state = 1}, [484] = {.lex_state = 41, .external_lex_state = 1}, [485] = {.lex_state = 41, .external_lex_state = 1}, @@ -6058,9 +6113,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [487] = {.lex_state = 41, .external_lex_state = 1}, [488] = {.lex_state = 41, .external_lex_state = 1}, [489] = {.lex_state = 41, .external_lex_state = 1}, - [490] = {.lex_state = 8}, + [490] = {.lex_state = 41, .external_lex_state = 1}, [491] = {.lex_state = 41, .external_lex_state = 1}, - [492] = {.lex_state = 41, .external_lex_state = 1}, + [492] = {.lex_state = 41, .external_lex_state = 2}, [493] = {.lex_state = 41, .external_lex_state = 1}, [494] = {.lex_state = 41, .external_lex_state = 1}, [495] = {.lex_state = 41, .external_lex_state = 1}, @@ -6070,25 +6125,25 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [499] = {.lex_state = 41, .external_lex_state = 1}, [500] = {.lex_state = 41, .external_lex_state = 1}, [501] = {.lex_state = 41, .external_lex_state = 1}, - [502] = {.lex_state = 41, .external_lex_state = 2}, - [503] = {.lex_state = 43}, + [502] = {.lex_state = 41, .external_lex_state = 1}, + [503] = {.lex_state = 41, .external_lex_state = 1}, [504] = {.lex_state = 41, .external_lex_state = 1}, - [505] = {.lex_state = 8}, - [506] = {.lex_state = 41, .external_lex_state = 2}, + [505] = {.lex_state = 41, .external_lex_state = 1}, + [506] = {.lex_state = 41, .external_lex_state = 1}, [507] = {.lex_state = 41, .external_lex_state = 1}, - [508] = {.lex_state = 41, .external_lex_state = 1}, + [508] = {.lex_state = 8}, [509] = {.lex_state = 41, .external_lex_state = 1}, [510] = {.lex_state = 41, .external_lex_state = 1}, [511] = {.lex_state = 41, .external_lex_state = 1}, - [512] = {.lex_state = 41, .external_lex_state = 2}, + [512] = {.lex_state = 41, .external_lex_state = 1}, [513] = {.lex_state = 41, .external_lex_state = 1}, [514] = {.lex_state = 41, .external_lex_state = 1}, [515] = {.lex_state = 41, .external_lex_state = 1}, [516] = {.lex_state = 41, .external_lex_state = 1}, [517] = {.lex_state = 41, .external_lex_state = 1}, - [518] = {.lex_state = 41, .external_lex_state = 2}, - [519] = {.lex_state = 41, .external_lex_state = 1}, - [520] = {.lex_state = 8}, + [518] = {.lex_state = 43}, + [519] = {.lex_state = 8}, + [520] = {.lex_state = 41, .external_lex_state = 1}, [521] = {.lex_state = 41, .external_lex_state = 1}, [522] = {.lex_state = 41, .external_lex_state = 1}, [523] = {.lex_state = 41, .external_lex_state = 1}, @@ -6096,113 +6151,113 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [525] = {.lex_state = 41, .external_lex_state = 1}, [526] = {.lex_state = 41, .external_lex_state = 1}, [527] = {.lex_state = 41, .external_lex_state = 1}, - [528] = {.lex_state = 41, .external_lex_state = 1}, + [528] = {.lex_state = 8}, [529] = {.lex_state = 41, .external_lex_state = 1}, - [530] = {.lex_state = 41, .external_lex_state = 2}, + [530] = {.lex_state = 41, .external_lex_state = 1}, [531] = {.lex_state = 41, .external_lex_state = 1}, [532] = {.lex_state = 41, .external_lex_state = 1}, [533] = {.lex_state = 41, .external_lex_state = 1}, - [534] = {.lex_state = 41, .external_lex_state = 1}, + [534] = {.lex_state = 41, .external_lex_state = 2}, [535] = {.lex_state = 41, .external_lex_state = 1}, [536] = {.lex_state = 41, .external_lex_state = 1}, [537] = {.lex_state = 41, .external_lex_state = 1}, - [538] = {.lex_state = 8}, + [538] = {.lex_state = 41, .external_lex_state = 1}, [539] = {.lex_state = 41, .external_lex_state = 2}, - [540] = {.lex_state = 8}, - [541] = {.lex_state = 41, .external_lex_state = 1}, - [542] = {.lex_state = 41, .external_lex_state = 2}, - [543] = {.lex_state = 8}, - [544] = {.lex_state = 41, .external_lex_state = 2}, - [545] = {.lex_state = 41, .external_lex_state = 2}, + [540] = {.lex_state = 41, .external_lex_state = 1}, + [541] = {.lex_state = 41, .external_lex_state = 2}, + [542] = {.lex_state = 41, .external_lex_state = 1}, + [543] = {.lex_state = 41, .external_lex_state = 2}, + [544] = {.lex_state = 41, .external_lex_state = 1}, + [545] = {.lex_state = 8}, [546] = {.lex_state = 41, .external_lex_state = 2}, - [547] = {.lex_state = 0}, + [547] = {.lex_state = 41, .external_lex_state = 2}, [548] = {.lex_state = 41, .external_lex_state = 2}, [549] = {.lex_state = 41, .external_lex_state = 2}, - [550] = {.lex_state = 41, .external_lex_state = 1}, - [551] = {.lex_state = 8}, - [552] = {.lex_state = 41, .external_lex_state = 1}, - [553] = {.lex_state = 41, .external_lex_state = 2}, - [554] = {.lex_state = 41, .external_lex_state = 1}, - [555] = {.lex_state = 41, .external_lex_state = 1}, + [550] = {.lex_state = 41, .external_lex_state = 2}, + [551] = {.lex_state = 41, .external_lex_state = 2}, + [552] = {.lex_state = 8}, + [553] = {.lex_state = 8}, + [554] = {.lex_state = 41, .external_lex_state = 2}, + [555] = {.lex_state = 41, .external_lex_state = 2}, [556] = {.lex_state = 41, .external_lex_state = 2}, [557] = {.lex_state = 41, .external_lex_state = 1}, - [558] = {.lex_state = 41, .external_lex_state = 2}, - [559] = {.lex_state = 41, .external_lex_state = 1}, - [560] = {.lex_state = 41, .external_lex_state = 2}, - [561] = {.lex_state = 41, .external_lex_state = 2}, + [558] = {.lex_state = 8}, + [559] = {.lex_state = 0}, + [560] = {.lex_state = 41, .external_lex_state = 1}, + [561] = {.lex_state = 41, .external_lex_state = 1}, [562] = {.lex_state = 41, .external_lex_state = 2}, [563] = {.lex_state = 41, .external_lex_state = 2}, - [564] = {.lex_state = 41, .external_lex_state = 1}, + [564] = {.lex_state = 41, .external_lex_state = 2}, [565] = {.lex_state = 41, .external_lex_state = 1}, [566] = {.lex_state = 41, .external_lex_state = 2}, - [567] = {.lex_state = 41, .external_lex_state = 1}, + [567] = {.lex_state = 41, .external_lex_state = 2}, [568] = {.lex_state = 41, .external_lex_state = 2}, [569] = {.lex_state = 41, .external_lex_state = 1}, [570] = {.lex_state = 41, .external_lex_state = 1}, [571] = {.lex_state = 41, .external_lex_state = 2}, - [572] = {.lex_state = 8}, + [572] = {.lex_state = 41, .external_lex_state = 1}, [573] = {.lex_state = 41, .external_lex_state = 2}, - [574] = {.lex_state = 41, .external_lex_state = 2}, - [575] = {.lex_state = 41, .external_lex_state = 2}, + [574] = {.lex_state = 41, .external_lex_state = 1}, + [575] = {.lex_state = 8}, [576] = {.lex_state = 41, .external_lex_state = 2}, [577] = {.lex_state = 41, .external_lex_state = 2}, [578] = {.lex_state = 41, .external_lex_state = 2}, [579] = {.lex_state = 41, .external_lex_state = 1}, - [580] = {.lex_state = 8}, + [580] = {.lex_state = 41, .external_lex_state = 2}, [581] = {.lex_state = 41, .external_lex_state = 2}, - [582] = {.lex_state = 8}, - [583] = {.lex_state = 41, .external_lex_state = 2}, + [582] = {.lex_state = 41, .external_lex_state = 1}, + [583] = {.lex_state = 8}, [584] = {.lex_state = 41, .external_lex_state = 2}, - [585] = {.lex_state = 41, .external_lex_state = 2}, - [586] = {.lex_state = 41, .external_lex_state = 1}, - [587] = {.lex_state = 41, .external_lex_state = 1}, + [585] = {.lex_state = 41, .external_lex_state = 1}, + [586] = {.lex_state = 41, .external_lex_state = 2}, + [587] = {.lex_state = 41, .external_lex_state = 2}, [588] = {.lex_state = 41, .external_lex_state = 1}, - [589] = {.lex_state = 41, .external_lex_state = 2}, - [590] = {.lex_state = 41, .external_lex_state = 2}, + [589] = {.lex_state = 41, .external_lex_state = 1}, + [590] = {.lex_state = 41, .external_lex_state = 1}, [591] = {.lex_state = 41, .external_lex_state = 1}, [592] = {.lex_state = 41, .external_lex_state = 1}, [593] = {.lex_state = 41, .external_lex_state = 1}, - [594] = {.lex_state = 8}, + [594] = {.lex_state = 0}, [595] = {.lex_state = 41, .external_lex_state = 1}, [596] = {.lex_state = 41, .external_lex_state = 1}, [597] = {.lex_state = 41, .external_lex_state = 1}, - [598] = {.lex_state = 41, .external_lex_state = 1}, + [598] = {.lex_state = 8}, [599] = {.lex_state = 41, .external_lex_state = 2}, [600] = {.lex_state = 41, .external_lex_state = 1}, [601] = {.lex_state = 41, .external_lex_state = 1}, [602] = {.lex_state = 41, .external_lex_state = 2}, [603] = {.lex_state = 41, .external_lex_state = 2}, - [604] = {.lex_state = 0}, + [604] = {.lex_state = 41, .external_lex_state = 2}, [605] = {.lex_state = 41, .external_lex_state = 2}, - [606] = {.lex_state = 41, .external_lex_state = 2}, + [606] = {.lex_state = 41, .external_lex_state = 1}, [607] = {.lex_state = 41, .external_lex_state = 1}, [608] = {.lex_state = 41, .external_lex_state = 1}, - [609] = {.lex_state = 41, .external_lex_state = 1}, + [609] = {.lex_state = 41, .external_lex_state = 2}, [610] = {.lex_state = 41, .external_lex_state = 1}, [611] = {.lex_state = 0}, - [612] = {.lex_state = 41, .external_lex_state = 2}, - [613] = {.lex_state = 8}, - [614] = {.lex_state = 41, .external_lex_state = 2}, - [615] = {.lex_state = 41, .external_lex_state = 2}, - [616] = {.lex_state = 8}, + [612] = {.lex_state = 0}, + [613] = {.lex_state = 41, .external_lex_state = 2}, + [614] = {.lex_state = 8}, + [615] = {.lex_state = 8}, + [616] = {.lex_state = 41, .external_lex_state = 2}, [617] = {.lex_state = 0}, - [618] = {.lex_state = 41, .external_lex_state = 2}, - [619] = {.lex_state = 8}, - [620] = {.lex_state = 41, .external_lex_state = 2}, - [621] = {.lex_state = 43}, - [622] = {.lex_state = 0}, - [623] = {.lex_state = 0}, + [618] = {.lex_state = 0}, + [619] = {.lex_state = 41, .external_lex_state = 2}, + [620] = {.lex_state = 8}, + [621] = {.lex_state = 0}, + [622] = {.lex_state = 41, .external_lex_state = 2}, + [623] = {.lex_state = 43}, [624] = {.lex_state = 41, .external_lex_state = 2}, - [625] = {.lex_state = 0}, + [625] = {.lex_state = 41, .external_lex_state = 2}, [626] = {.lex_state = 41, .external_lex_state = 2}, [627] = {.lex_state = 8}, [628] = {.lex_state = 8}, [629] = {.lex_state = 8}, [630] = {.lex_state = 8}, - [631] = {.lex_state = 8}, - [632] = {.lex_state = 8}, - [633] = {.lex_state = 43}, - [634] = {.lex_state = 43}, + [631] = {.lex_state = 43}, + [632] = {.lex_state = 43}, + [633] = {.lex_state = 8}, + [634] = {.lex_state = 8}, [635] = {.lex_state = 0}, [636] = {.lex_state = 0}, [637] = {.lex_state = 0}, @@ -6217,29 +6272,29 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [646] = {.lex_state = 43}, [647] = {.lex_state = 43}, [648] = {.lex_state = 43}, - [649] = {.lex_state = 43}, - [650] = {.lex_state = 0}, - [651] = {.lex_state = 0}, - [652] = {.lex_state = 0}, - [653] = {.lex_state = 8}, - [654] = {.lex_state = 8}, - [655] = {.lex_state = 43}, + [649] = {.lex_state = 8}, + [650] = {.lex_state = 43}, + [651] = {.lex_state = 8}, + [652] = {.lex_state = 8}, + [653] = {.lex_state = 0}, + [654] = {.lex_state = 43}, + [655] = {.lex_state = 0}, [656] = {.lex_state = 0}, - [657] = {.lex_state = 8}, + [657] = {.lex_state = 0}, [658] = {.lex_state = 0}, - [659] = {.lex_state = 41}, + [659] = {.lex_state = 0}, [660] = {.lex_state = 0}, - [661] = {.lex_state = 0}, - [662] = {.lex_state = 41}, - [663] = {.lex_state = 10}, + [661] = {.lex_state = 41}, + [662] = {.lex_state = 10}, + [663] = {.lex_state = 0}, [664] = {.lex_state = 0}, - [665] = {.lex_state = 0}, + [665] = {.lex_state = 10}, [666] = {.lex_state = 0}, - [667] = {.lex_state = 10}, - [668] = {.lex_state = 0}, - [669] = {.lex_state = 41}, - [670] = {.lex_state = 0}, - [671] = {.lex_state = 10}, + [667] = {.lex_state = 41}, + [668] = {.lex_state = 41}, + [669] = {.lex_state = 0}, + [670] = {.lex_state = 10}, + [671] = {.lex_state = 0}, [672] = {.lex_state = 0}, [673] = {.lex_state = 0}, [674] = {.lex_state = 10}, @@ -6249,17 +6304,17 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [678] = {.lex_state = 0}, [679] = {.lex_state = 0}, [680] = {.lex_state = 0}, - [681] = {.lex_state = 41}, + [681] = {.lex_state = 0}, [682] = {.lex_state = 0}, [683] = {.lex_state = 0}, - [684] = {.lex_state = 0}, - [685] = {.lex_state = 8}, - [686] = {.lex_state = 41}, + [684] = {.lex_state = 41}, + [685] = {.lex_state = 41}, + [686] = {.lex_state = 8}, [687] = {.lex_state = 41}, [688] = {.lex_state = 41}, [689] = {.lex_state = 0}, [690] = {.lex_state = 0}, - [691] = {.lex_state = 8}, + [691] = {.lex_state = 0}, [692] = {.lex_state = 0}, [693] = {.lex_state = 0}, [694] = {.lex_state = 0}, @@ -6324,20 +6379,20 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [753] = {.lex_state = 0}, [754] = {.lex_state = 0}, [755] = {.lex_state = 0}, - [756] = {.lex_state = 0}, + [756] = {.lex_state = 8}, [757] = {.lex_state = 0}, [758] = {.lex_state = 0}, [759] = {.lex_state = 0}, [760] = {.lex_state = 0}, - [761] = {.lex_state = 41}, + [761] = {.lex_state = 0}, [762] = {.lex_state = 0}, - [763] = {.lex_state = 0}, - [764] = {.lex_state = 0}, - [765] = {.lex_state = 10}, + [763] = {.lex_state = 10}, + [764] = {.lex_state = 41}, + [765] = {.lex_state = 0}, [766] = {.lex_state = 0}, - [767] = {.lex_state = 0}, + [767] = {.lex_state = 41}, [768] = {.lex_state = 0}, - [769] = {.lex_state = 0}, + [769] = {.lex_state = 10}, [770] = {.lex_state = 0}, [771] = {.lex_state = 0}, [772] = {.lex_state = 0}, @@ -6350,15 +6405,15 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [779] = {.lex_state = 0}, [780] = {.lex_state = 0}, [781] = {.lex_state = 0}, - [782] = {.lex_state = 0}, + [782] = {.lex_state = 10}, [783] = {.lex_state = 0}, [784] = {.lex_state = 0}, [785] = {.lex_state = 0}, [786] = {.lex_state = 0}, [787] = {.lex_state = 0}, [788] = {.lex_state = 0}, - [789] = {.lex_state = 10}, - [790] = {.lex_state = 0}, + [789] = {.lex_state = 0}, + [790] = {.lex_state = 10}, [791] = {.lex_state = 0}, [792] = {.lex_state = 0}, [793] = {.lex_state = 0}, @@ -6367,80 +6422,80 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [796] = {.lex_state = 0}, [797] = {.lex_state = 0}, [798] = {.lex_state = 0}, - [799] = {.lex_state = 10}, + [799] = {.lex_state = 0}, [800] = {.lex_state = 0}, - [801] = {.lex_state = 10}, + [801] = {.lex_state = 0}, [802] = {.lex_state = 0}, - [803] = {.lex_state = 8}, - [804] = {.lex_state = 8}, + [803] = {.lex_state = 0}, + [804] = {.lex_state = 0}, [805] = {.lex_state = 43}, - [806] = {.lex_state = 43}, - [807] = {.lex_state = 8}, - [808] = {.lex_state = 8}, + [806] = {.lex_state = 41}, + [807] = {.lex_state = 0}, + [808] = {.lex_state = 0}, [809] = {.lex_state = 8}, [810] = {.lex_state = 0}, [811] = {.lex_state = 41}, - [812] = {.lex_state = 0}, - [813] = {.lex_state = 0}, - [814] = {.lex_state = 41}, - [815] = {.lex_state = 41}, + [812] = {.lex_state = 41}, + [813] = {.lex_state = 8}, + [814] = {.lex_state = 43}, + [815] = {.lex_state = 0}, [816] = {.lex_state = 41}, - [817] = {.lex_state = 41}, - [818] = {.lex_state = 0}, - [819] = {.lex_state = 41}, + [817] = {.lex_state = 8}, + [818] = {.lex_state = 41}, + [819] = {.lex_state = 8}, [820] = {.lex_state = 41}, [821] = {.lex_state = 41}, - [822] = {.lex_state = 0}, - [823] = {.lex_state = 41}, + [822] = {.lex_state = 41}, + [823] = {.lex_state = 8}, [824] = {.lex_state = 41}, [825] = {.lex_state = 41}, - [826] = {.lex_state = 41}, - [827] = {.lex_state = 16}, + [826] = {.lex_state = 43}, + [827] = {.lex_state = 41}, [828] = {.lex_state = 41}, [829] = {.lex_state = 16}, [830] = {.lex_state = 41}, - [831] = {.lex_state = 41}, + [831] = {.lex_state = 16}, [832] = {.lex_state = 41}, - [833] = {.lex_state = 0}, + [833] = {.lex_state = 41}, [834] = {.lex_state = 41}, - [835] = {.lex_state = 43}, + [835] = {.lex_state = 41}, [836] = {.lex_state = 41}, - [837] = {.lex_state = 41}, - [838] = {.lex_state = 43}, + [837] = {.lex_state = 43}, + [838] = {.lex_state = 0}, [839] = {.lex_state = 41}, - [840] = {.lex_state = 41}, + [840] = {.lex_state = 0}, [841] = {.lex_state = 41}, - [842] = {.lex_state = 0}, - [843] = {.lex_state = 0}, + [842] = {.lex_state = 41}, + [843] = {.lex_state = 41}, [844] = {.lex_state = 41}, - [845] = {.lex_state = 8, .external_lex_state = 3}, + [845] = {.lex_state = 41}, [846] = {.lex_state = 41}, - [847] = {.lex_state = 41}, + [847] = {.lex_state = 0}, [848] = {.lex_state = 41}, - [849] = {.lex_state = 41}, + [849] = {.lex_state = 0}, [850] = {.lex_state = 41}, - [851] = {.lex_state = 41}, + [851] = {.lex_state = 0}, [852] = {.lex_state = 41}, [853] = {.lex_state = 41}, [854] = {.lex_state = 41}, [855] = {.lex_state = 41}, [856] = {.lex_state = 41}, [857] = {.lex_state = 41}, - [858] = {.lex_state = 0}, - [859] = {.lex_state = 0}, + [858] = {.lex_state = 41}, + [859] = {.lex_state = 41}, [860] = {.lex_state = 41}, [861] = {.lex_state = 41}, - [862] = {.lex_state = 41}, + [862] = {.lex_state = 8, .external_lex_state = 3}, [863] = {.lex_state = 41}, - [864] = {.lex_state = 41}, + [864] = {.lex_state = 8, .external_lex_state = 3}, [865] = {.lex_state = 41}, - [866] = {.lex_state = 8, .external_lex_state = 3}, - [867] = {.lex_state = 8, .external_lex_state = 3}, + [866] = {.lex_state = 41}, + [867] = {.lex_state = 41}, [868] = {.lex_state = 41}, - [869] = {.lex_state = 41}, + [869] = {.lex_state = 0}, [870] = {.lex_state = 41}, [871] = {.lex_state = 41}, - [872] = {.lex_state = 41}, + [872] = {.lex_state = 0}, [873] = {.lex_state = 41}, [874] = {.lex_state = 41}, [875] = {.lex_state = 41}, @@ -6448,41 +6503,41 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [877] = {.lex_state = 41}, [878] = {.lex_state = 41}, [879] = {.lex_state = 0}, - [880] = {.lex_state = 0}, + [880] = {.lex_state = 41}, [881] = {.lex_state = 0}, - [882] = {.lex_state = 0}, - [883] = {.lex_state = 41}, - [884] = {.lex_state = 41}, + [882] = {.lex_state = 41}, + [883] = {.lex_state = 0}, + [884] = {.lex_state = 0}, [885] = {.lex_state = 41}, - [886] = {.lex_state = 41}, + [886] = {.lex_state = 0}, [887] = {.lex_state = 41}, [888] = {.lex_state = 41}, [889] = {.lex_state = 41}, [890] = {.lex_state = 41}, [891] = {.lex_state = 0}, - [892] = {.lex_state = 41}, - [893] = {.lex_state = 41}, - [894] = {.lex_state = 0}, - [895] = {.lex_state = 0}, + [892] = {.lex_state = 0}, + [893] = {.lex_state = 0}, + [894] = {.lex_state = 41}, + [895] = {.lex_state = 41}, [896] = {.lex_state = 41}, - [897] = {.lex_state = 41}, - [898] = {.lex_state = 0}, + [897] = {.lex_state = 0}, + [898] = {.lex_state = 41}, [899] = {.lex_state = 41}, [900] = {.lex_state = 41}, [901] = {.lex_state = 41}, [902] = {.lex_state = 41}, - [903] = {.lex_state = 0}, + [903] = {.lex_state = 41}, [904] = {.lex_state = 41}, [905] = {.lex_state = 41}, - [906] = {.lex_state = 41}, + [906] = {.lex_state = 0}, [907] = {.lex_state = 41}, [908] = {.lex_state = 0}, - [909] = {.lex_state = 41}, + [909] = {.lex_state = 0}, [910] = {.lex_state = 41}, [911] = {.lex_state = 41}, - [912] = {.lex_state = 41}, + [912] = {.lex_state = 0}, [913] = {.lex_state = 41}, - [914] = {.lex_state = 41}, + [914] = {.lex_state = 0}, [915] = {.lex_state = 41}, [916] = {.lex_state = 41}, [917] = {.lex_state = 41}, @@ -6490,77 +6545,77 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [919] = {.lex_state = 41}, [920] = {.lex_state = 41}, [921] = {.lex_state = 41}, - [922] = {.lex_state = 0}, - [923] = {.lex_state = 0}, + [922] = {.lex_state = 8, .external_lex_state = 3}, + [923] = {.lex_state = 41}, [924] = {.lex_state = 41}, [925] = {.lex_state = 41}, [926] = {.lex_state = 41}, [927] = {.lex_state = 41}, [928] = {.lex_state = 41}, [929] = {.lex_state = 41}, - [930] = {.lex_state = 0}, + [930] = {.lex_state = 41}, [931] = {.lex_state = 41}, - [932] = {.lex_state = 0}, + [932] = {.lex_state = 41}, [933] = {.lex_state = 41}, - [934] = {.lex_state = 0}, - [935] = {.lex_state = 0}, + [934] = {.lex_state = 41}, + [935] = {.lex_state = 41}, [936] = {.lex_state = 41}, [937] = {.lex_state = 41}, - [938] = {.lex_state = 8, .external_lex_state = 3}, - [939] = {.lex_state = 0}, - [940] = {.lex_state = 0}, - [941] = {.lex_state = 0}, - [942] = {.lex_state = 0}, + [938] = {.lex_state = 41}, + [939] = {.lex_state = 41}, + [940] = {.lex_state = 8, .external_lex_state = 3}, + [941] = {.lex_state = 41}, + [942] = {.lex_state = 8, .external_lex_state = 3}, [943] = {.lex_state = 0}, [944] = {.lex_state = 0}, - [945] = {.lex_state = 0}, + [945] = {.lex_state = 8, .external_lex_state = 3}, [946] = {.lex_state = 0}, - [947] = {.lex_state = 41}, + [947] = {.lex_state = 0}, [948] = {.lex_state = 0}, [949] = {.lex_state = 41}, - [950] = {.lex_state = 0}, + [950] = {.lex_state = 41}, [951] = {.lex_state = 41}, - [952] = {.lex_state = 41}, - [953] = {.lex_state = 0}, - [954] = {.lex_state = 8, .external_lex_state = 3}, - [955] = {.lex_state = 8, .external_lex_state = 3}, + [952] = {.lex_state = 0}, + [953] = {.lex_state = 41}, + [954] = {.lex_state = 0}, + [955] = {.lex_state = 41}, [956] = {.lex_state = 41}, - [957] = {.lex_state = 0}, - [958] = {.lex_state = 41}, - [959] = {.lex_state = 41}, - [960] = {.lex_state = 41}, + [957] = {.lex_state = 41}, + [958] = {.lex_state = 0}, + [959] = {.lex_state = 0}, + [960] = {.lex_state = 0}, [961] = {.lex_state = 41}, - [962] = {.lex_state = 41}, + [962] = {.lex_state = 0}, [963] = {.lex_state = 0}, [964] = {.lex_state = 0}, [965] = {.lex_state = 41}, [966] = {.lex_state = 0}, [967] = {.lex_state = 41}, - [968] = {.lex_state = 0}, + [968] = {.lex_state = 41}, [969] = {.lex_state = 41}, - [970] = {.lex_state = 9}, - [971] = {.lex_state = 41}, - [972] = {.lex_state = 41}, + [970] = {.lex_state = 0}, + [971] = {.lex_state = 0}, + [972] = {.lex_state = 9}, [973] = {.lex_state = 9}, [974] = {.lex_state = 9}, [975] = {.lex_state = 9}, [976] = {.lex_state = 9}, [977] = {.lex_state = 9}, - [978] = {.lex_state = 9}, + [978] = {.lex_state = 41}, [979] = {.lex_state = 9}, - [980] = {.lex_state = 8, .external_lex_state = 3}, + [980] = {.lex_state = 41}, [981] = {.lex_state = 9}, [982] = {.lex_state = 9}, - [983] = {.lex_state = 9}, - [984] = {.lex_state = 9}, + [983] = {.lex_state = 41}, + [984] = {.lex_state = 8, .external_lex_state = 3}, [985] = {.lex_state = 9}, - [986] = {.lex_state = 41}, + [986] = {.lex_state = 9}, [987] = {.lex_state = 9}, [988] = {.lex_state = 9}, [989] = {.lex_state = 9}, - [990] = {.lex_state = 41}, + [990] = {.lex_state = 9}, [991] = {.lex_state = 41}, - [992] = {.lex_state = 41}, + [992] = {.lex_state = 9}, [993] = {.lex_state = 41}, [994] = {.lex_state = 41}, [995] = {.lex_state = 41}, @@ -6573,18 +6628,18 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1002] = {.lex_state = 41}, [1003] = {.lex_state = 41}, [1004] = {.lex_state = 41}, - [1005] = {.lex_state = 8, .external_lex_state = 3}, + [1005] = {.lex_state = 41}, [1006] = {.lex_state = 41}, [1007] = {.lex_state = 41}, [1008] = {.lex_state = 41}, - [1009] = {.lex_state = 41}, + [1009] = {.lex_state = 8, .external_lex_state = 3}, [1010] = {.lex_state = 41}, [1011] = {.lex_state = 41}, [1012] = {.lex_state = 41}, [1013] = {.lex_state = 41}, [1014] = {.lex_state = 41}, [1015] = {.lex_state = 41}, - [1016] = {.lex_state = 16}, + [1016] = {.lex_state = 41}, [1017] = {.lex_state = 41}, [1018] = {.lex_state = 8}, [1019] = {.lex_state = 41}, @@ -6594,18 +6649,18 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1023] = {.lex_state = 41}, [1024] = {.lex_state = 41}, [1025] = {.lex_state = 41}, - [1026] = {.lex_state = 8}, + [1026] = {.lex_state = 41}, [1027] = {.lex_state = 41}, - [1028] = {.lex_state = 0}, + [1028] = {.lex_state = 41}, [1029] = {.lex_state = 41}, [1030] = {.lex_state = 41}, - [1031] = {.lex_state = 41, .external_lex_state = 3}, + [1031] = {.lex_state = 41}, [1032] = {.lex_state = 41}, - [1033] = {.lex_state = 8}, + [1033] = {.lex_state = 0}, [1034] = {.lex_state = 41}, - [1035] = {.lex_state = 41}, + [1035] = {.lex_state = 8}, [1036] = {.lex_state = 41}, - [1037] = {.lex_state = 41}, + [1037] = {.lex_state = 41, .external_lex_state = 3}, [1038] = {.lex_state = 41}, [1039] = {.lex_state = 41}, [1040] = {.lex_state = 41}, @@ -6619,98 +6674,98 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1048] = {.lex_state = 41}, [1049] = {.lex_state = 41}, [1050] = {.lex_state = 41}, - [1051] = {.lex_state = 41}, + [1051] = {.lex_state = 8}, [1052] = {.lex_state = 41}, - [1053] = {.lex_state = 0}, + [1053] = {.lex_state = 41}, [1054] = {.lex_state = 41}, [1055] = {.lex_state = 41}, - [1056] = {.lex_state = 8}, - [1057] = {.lex_state = 8, .external_lex_state = 3}, - [1058] = {.lex_state = 8}, - [1059] = {.lex_state = 16}, - [1060] = {.lex_state = 8, .external_lex_state = 3}, - [1061] = {.lex_state = 16}, - [1062] = {.lex_state = 41}, + [1056] = {.lex_state = 41}, + [1057] = {.lex_state = 41}, + [1058] = {.lex_state = 41}, + [1059] = {.lex_state = 41}, + [1060] = {.lex_state = 41}, + [1061] = {.lex_state = 41}, + [1062] = {.lex_state = 16}, [1063] = {.lex_state = 41}, [1064] = {.lex_state = 41}, [1065] = {.lex_state = 41}, - [1066] = {.lex_state = 41, .external_lex_state = 3}, - [1067] = {.lex_state = 41}, - [1068] = {.lex_state = 41, .external_lex_state = 3}, - [1069] = {.lex_state = 16}, + [1066] = {.lex_state = 41}, + [1067] = {.lex_state = 0}, + [1068] = {.lex_state = 41}, + [1069] = {.lex_state = 41}, [1070] = {.lex_state = 41}, - [1071] = {.lex_state = 41}, - [1072] = {.lex_state = 41}, - [1073] = {.lex_state = 41}, - [1074] = {.lex_state = 8}, - [1075] = {.lex_state = 41, .external_lex_state = 3}, - [1076] = {.lex_state = 41}, - [1077] = {.lex_state = 41}, - [1078] = {.lex_state = 8}, - [1079] = {.lex_state = 41}, + [1071] = {.lex_state = 16}, + [1072] = {.lex_state = 8, .external_lex_state = 3}, + [1073] = {.lex_state = 16}, + [1074] = {.lex_state = 41}, + [1075] = {.lex_state = 16}, + [1076] = {.lex_state = 16}, + [1077] = {.lex_state = 16}, + [1078] = {.lex_state = 16}, + [1079] = {.lex_state = 16}, [1080] = {.lex_state = 41}, - [1081] = {.lex_state = 16}, - [1082] = {.lex_state = 16}, - [1083] = {.lex_state = 8}, + [1081] = {.lex_state = 41, .external_lex_state = 3}, + [1082] = {.lex_state = 41, .external_lex_state = 3}, + [1083] = {.lex_state = 16}, [1084] = {.lex_state = 41}, - [1085] = {.lex_state = 16}, - [1086] = {.lex_state = 16}, - [1087] = {.lex_state = 41}, + [1085] = {.lex_state = 41}, + [1086] = {.lex_state = 8}, + [1087] = {.lex_state = 16}, [1088] = {.lex_state = 41}, - [1089] = {.lex_state = 16}, - [1090] = {.lex_state = 41}, - [1091] = {.lex_state = 16}, - [1092] = {.lex_state = 41, .external_lex_state = 3}, - [1093] = {.lex_state = 16}, - [1094] = {.lex_state = 41}, - [1095] = {.lex_state = 16}, - [1096] = {.lex_state = 16}, + [1089] = {.lex_state = 41}, + [1090] = {.lex_state = 16}, + [1091] = {.lex_state = 8}, + [1092] = {.lex_state = 8}, + [1093] = {.lex_state = 8}, + [1094] = {.lex_state = 8}, + [1095] = {.lex_state = 8, .external_lex_state = 3}, + [1096] = {.lex_state = 41}, [1097] = {.lex_state = 41}, - [1098] = {.lex_state = 41}, - [1099] = {.lex_state = 16}, + [1098] = {.lex_state = 16}, + [1099] = {.lex_state = 41, .external_lex_state = 3}, [1100] = {.lex_state = 41}, - [1101] = {.lex_state = 41}, - [1102] = {.lex_state = 41}, - [1103] = {.lex_state = 16}, - [1104] = {.lex_state = 8}, - [1105] = {.lex_state = 8}, - [1106] = {.lex_state = 8, .external_lex_state = 3}, - [1107] = {.lex_state = 41}, - [1108] = {.lex_state = 41}, - [1109] = {.lex_state = 8, .external_lex_state = 3}, + [1101] = {.lex_state = 8}, + [1102] = {.lex_state = 8}, + [1103] = {.lex_state = 41}, + [1104] = {.lex_state = 41}, + [1105] = {.lex_state = 16}, + [1106] = {.lex_state = 41}, + [1107] = {.lex_state = 16}, + [1108] = {.lex_state = 8}, + [1109] = {.lex_state = 41}, [1110] = {.lex_state = 41}, - [1111] = {.lex_state = 41}, - [1112] = {.lex_state = 16}, - [1113] = {.lex_state = 8}, - [1114] = {.lex_state = 41}, - [1115] = {.lex_state = 16}, - [1116] = {.lex_state = 16}, - [1117] = {.lex_state = 8}, - [1118] = {.lex_state = 41}, - [1119] = {.lex_state = 41}, + [1111] = {.lex_state = 16}, + [1112] = {.lex_state = 41}, + [1113] = {.lex_state = 8, .external_lex_state = 3}, + [1114] = {.lex_state = 8}, + [1115] = {.lex_state = 41, .external_lex_state = 3}, + [1116] = {.lex_state = 8, .external_lex_state = 3}, + [1117] = {.lex_state = 16}, + [1118] = {.lex_state = 16}, + [1119] = {.lex_state = 16}, [1120] = {.lex_state = 41}, - [1121] = {.lex_state = 16}, - [1122] = {.lex_state = 41, .external_lex_state = 3}, + [1121] = {.lex_state = 41}, + [1122] = {.lex_state = 41}, [1123] = {.lex_state = 41}, [1124] = {.lex_state = 41}, [1125] = {.lex_state = 41}, [1126] = {.lex_state = 41}, - [1127] = {.lex_state = 41}, - [1128] = {.lex_state = 41}, - [1129] = {.lex_state = 8}, + [1127] = {.lex_state = 41, .external_lex_state = 3}, + [1128] = {.lex_state = 8}, + [1129] = {.lex_state = 41}, [1130] = {.lex_state = 41}, [1131] = {.lex_state = 41}, [1132] = {.lex_state = 41}, - [1133] = {.lex_state = 16}, - [1134] = {.lex_state = 41, .external_lex_state = 3}, + [1133] = {.lex_state = 41}, + [1134] = {.lex_state = 41}, [1135] = {.lex_state = 41}, [1136] = {.lex_state = 41}, [1137] = {.lex_state = 41}, [1138] = {.lex_state = 41}, - [1139] = {.lex_state = 41}, + [1139] = {.lex_state = 41, .external_lex_state = 3}, [1140] = {.lex_state = 41}, [1141] = {.lex_state = 41}, - [1142] = {.lex_state = 41}, + [1142] = {.lex_state = 41, .external_lex_state = 3}, [1143] = {.lex_state = 41}, [1144] = {.lex_state = 41}, [1145] = {.lex_state = 41}, @@ -6718,8 +6773,8 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1147] = {.lex_state = 41}, [1148] = {.lex_state = 41}, [1149] = {.lex_state = 41}, - [1150] = {.lex_state = 41}, - [1151] = {.lex_state = 41}, + [1150] = {.lex_state = 8}, + [1151] = {.lex_state = 8}, [1152] = {.lex_state = 41}, [1153] = {.lex_state = 41}, [1154] = {.lex_state = 41}, @@ -6731,594 +6786,604 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [1160] = {.lex_state = 41}, [1161] = {.lex_state = 41}, [1162] = {.lex_state = 41}, - [1163] = {.lex_state = 41}, + [1163] = {.lex_state = 8}, [1164] = {.lex_state = 41}, [1165] = {.lex_state = 41}, [1166] = {.lex_state = 41}, [1167] = {.lex_state = 41}, [1168] = {.lex_state = 41}, [1169] = {.lex_state = 41}, - [1170] = {.lex_state = 41}, + [1170] = {.lex_state = 8, .external_lex_state = 3}, [1171] = {.lex_state = 41}, - [1172] = {.lex_state = 41}, + [1172] = {.lex_state = 8, .external_lex_state = 3}, [1173] = {.lex_state = 41}, [1174] = {.lex_state = 41}, - [1175] = {.lex_state = 41}, + [1175] = {.lex_state = 16}, [1176] = {.lex_state = 41}, [1177] = {.lex_state = 41}, [1178] = {.lex_state = 41}, [1179] = {.lex_state = 41}, - [1180] = {.lex_state = 41}, - [1181] = {.lex_state = 41}, + [1180] = {.lex_state = 41, .external_lex_state = 3}, + [1181] = {.lex_state = 8}, [1182] = {.lex_state = 41}, [1183] = {.lex_state = 41}, - [1184] = {.lex_state = 41}, + [1184] = {.lex_state = 16}, [1185] = {.lex_state = 41}, [1186] = {.lex_state = 41}, - [1187] = {.lex_state = 16}, + [1187] = {.lex_state = 41}, [1188] = {.lex_state = 41}, [1189] = {.lex_state = 41}, - [1190] = {.lex_state = 41}, - [1191] = {.lex_state = 41}, + [1190] = {.lex_state = 8}, + [1191] = {.lex_state = 8}, [1192] = {.lex_state = 41}, [1193] = {.lex_state = 41}, [1194] = {.lex_state = 41}, - [1195] = {.lex_state = 8}, + [1195] = {.lex_state = 41}, [1196] = {.lex_state = 41}, [1197] = {.lex_state = 41}, - [1198] = {.lex_state = 8}, + [1198] = {.lex_state = 41}, [1199] = {.lex_state = 41}, [1200] = {.lex_state = 41}, [1201] = {.lex_state = 41}, - [1202] = {.lex_state = 41}, + [1202] = {.lex_state = 8, .external_lex_state = 3}, [1203] = {.lex_state = 41}, [1204] = {.lex_state = 41}, [1205] = {.lex_state = 41}, - [1206] = {.lex_state = 41}, + [1206] = {.lex_state = 41, .external_lex_state = 3}, [1207] = {.lex_state = 41}, [1208] = {.lex_state = 41}, [1209] = {.lex_state = 41}, - [1210] = {.lex_state = 41, .external_lex_state = 3}, + [1210] = {.lex_state = 41}, [1211] = {.lex_state = 41}, - [1212] = {.lex_state = 41}, - [1213] = {.lex_state = 41}, + [1212] = {.lex_state = 41, .external_lex_state = 3}, + [1213] = {.lex_state = 16}, [1214] = {.lex_state = 41}, [1215] = {.lex_state = 41}, [1216] = {.lex_state = 41}, [1217] = {.lex_state = 41}, - [1218] = {.lex_state = 8, .external_lex_state = 3}, + [1218] = {.lex_state = 41}, [1219] = {.lex_state = 41}, - [1220] = {.lex_state = 8, .external_lex_state = 3}, - [1221] = {.lex_state = 41}, - [1222] = {.lex_state = 41, .external_lex_state = 3}, + [1220] = {.lex_state = 41}, + [1221] = {.lex_state = 8}, + [1222] = {.lex_state = 41}, [1223] = {.lex_state = 41}, - [1224] = {.lex_state = 41, .external_lex_state = 3}, - [1225] = {.lex_state = 16}, - [1226] = {.lex_state = 8}, + [1224] = {.lex_state = 41}, + [1225] = {.lex_state = 41}, + [1226] = {.lex_state = 41}, [1227] = {.lex_state = 41}, [1228] = {.lex_state = 41}, [1229] = {.lex_state = 41}, - [1230] = {.lex_state = 8, .external_lex_state = 3}, - [1231] = {.lex_state = 41}, + [1230] = {.lex_state = 41}, + [1231] = {.lex_state = 8}, [1232] = {.lex_state = 41}, [1233] = {.lex_state = 41}, [1234] = {.lex_state = 41}, [1235] = {.lex_state = 41}, [1236] = {.lex_state = 41}, - [1237] = {.lex_state = 41, .external_lex_state = 3}, + [1237] = {.lex_state = 41}, [1238] = {.lex_state = 41}, [1239] = {.lex_state = 41}, [1240] = {.lex_state = 41}, - [1241] = {.lex_state = 41, .external_lex_state = 3}, - [1242] = {.lex_state = 8}, + [1241] = {.lex_state = 41}, + [1242] = {.lex_state = 41}, [1243] = {.lex_state = 41}, [1244] = {.lex_state = 41}, [1245] = {.lex_state = 41}, [1246] = {.lex_state = 41}, [1247] = {.lex_state = 41}, - [1248] = {.lex_state = 41}, + [1248] = {.lex_state = 41, .external_lex_state = 3}, [1249] = {.lex_state = 41}, - [1250] = {.lex_state = 8}, - [1251] = {.lex_state = 41, .external_lex_state = 3}, + [1250] = {.lex_state = 41, .external_lex_state = 3}, + [1251] = {.lex_state = 41}, [1252] = {.lex_state = 41}, [1253] = {.lex_state = 41}, [1254] = {.lex_state = 41}, [1255] = {.lex_state = 41}, [1256] = {.lex_state = 41}, [1257] = {.lex_state = 41}, - [1258] = {.lex_state = 41}, + [1258] = {.lex_state = 8}, [1259] = {.lex_state = 41}, [1260] = {.lex_state = 41}, [1261] = {.lex_state = 41}, - [1262] = {.lex_state = 8}, + [1262] = {.lex_state = 41}, [1263] = {.lex_state = 41}, - [1264] = {.lex_state = 41, .external_lex_state = 3}, + [1264] = {.lex_state = 41}, [1265] = {.lex_state = 41}, - [1266] = {.lex_state = 16}, + [1266] = {.lex_state = 8}, [1267] = {.lex_state = 41}, - [1268] = {.lex_state = 41, .external_lex_state = 3}, + [1268] = {.lex_state = 16}, [1269] = {.lex_state = 41}, [1270] = {.lex_state = 41}, [1271] = {.lex_state = 41}, - [1272] = {.lex_state = 41}, - [1273] = {.lex_state = 8}, - [1274] = {.lex_state = 41}, - [1275] = {.lex_state = 16, .external_lex_state = 3}, + [1272] = {.lex_state = 16, .external_lex_state = 3}, + [1273] = {.lex_state = 41}, + [1274] = {.lex_state = 41, .external_lex_state = 3}, + [1275] = {.lex_state = 8}, [1276] = {.lex_state = 41}, - [1277] = {.lex_state = 41}, + [1277] = {.lex_state = 16, .external_lex_state = 3}, [1278] = {.lex_state = 41}, [1279] = {.lex_state = 41}, [1280] = {.lex_state = 41}, [1281] = {.lex_state = 41}, [1282] = {.lex_state = 41}, - [1283] = {.lex_state = 8}, + [1283] = {.lex_state = 41}, [1284] = {.lex_state = 41}, [1285] = {.lex_state = 41}, - [1286] = {.lex_state = 16}, - [1287] = {.lex_state = 9}, - [1288] = {.lex_state = 41, .external_lex_state = 3}, + [1286] = {.lex_state = 41}, + [1287] = {.lex_state = 41}, + [1288] = {.lex_state = 41}, [1289] = {.lex_state = 41}, - [1290] = {.lex_state = 41}, + [1290] = {.lex_state = 16}, [1291] = {.lex_state = 41}, [1292] = {.lex_state = 41}, [1293] = {.lex_state = 41}, - [1294] = {.lex_state = 41}, - [1295] = {.lex_state = 41, .external_lex_state = 3}, + [1294] = {.lex_state = 9}, + [1295] = {.lex_state = 16}, [1296] = {.lex_state = 41}, - [1297] = {.lex_state = 8}, - [1298] = {.lex_state = 16, .external_lex_state = 3}, - [1299] = {.lex_state = 8}, + [1297] = {.lex_state = 41}, + [1298] = {.lex_state = 41}, + [1299] = {.lex_state = 41}, [1300] = {.lex_state = 41}, [1301] = {.lex_state = 41}, - [1302] = {.lex_state = 16}, + [1302] = {.lex_state = 8}, [1303] = {.lex_state = 8}, - [1304] = {.lex_state = 41}, - [1305] = {.lex_state = 16, .external_lex_state = 3}, - [1306] = {.lex_state = 8}, - [1307] = {.lex_state = 16}, - [1308] = {.lex_state = 41}, - [1309] = {.lex_state = 41, .external_lex_state = 3}, - [1310] = {.lex_state = 8}, - [1311] = {.lex_state = 9}, - [1312] = {.lex_state = 41, .external_lex_state = 3}, - [1313] = {.lex_state = 41}, - [1314] = {.lex_state = 8}, - [1315] = {.lex_state = 41}, - [1316] = {.lex_state = 41}, + [1304] = {.lex_state = 16, .external_lex_state = 3}, + [1305] = {.lex_state = 41}, + [1306] = {.lex_state = 41, .external_lex_state = 3}, + [1307] = {.lex_state = 41, .external_lex_state = 3}, + [1308] = {.lex_state = 41, .external_lex_state = 3}, + [1309] = {.lex_state = 41}, + [1310] = {.lex_state = 41}, + [1311] = {.lex_state = 41}, + [1312] = {.lex_state = 41}, + [1313] = {.lex_state = 8}, + [1314] = {.lex_state = 41, .external_lex_state = 3}, + [1315] = {.lex_state = 16}, + [1316] = {.lex_state = 9}, [1317] = {.lex_state = 41}, [1318] = {.lex_state = 41}, - [1319] = {.lex_state = 41}, - [1320] = {.lex_state = 41}, - [1321] = {.lex_state = 8}, + [1319] = {.lex_state = 41, .external_lex_state = 3}, + [1320] = {.lex_state = 16}, + [1321] = {.lex_state = 41}, [1322] = {.lex_state = 41}, - [1323] = {.lex_state = 41}, + [1323] = {.lex_state = 16}, [1324] = {.lex_state = 41}, - [1325] = {.lex_state = 41}, + [1325] = {.lex_state = 8}, [1326] = {.lex_state = 41}, [1327] = {.lex_state = 8}, - [1328] = {.lex_state = 41}, - [1329] = {.lex_state = 8}, + [1328] = {.lex_state = 9}, + [1329] = {.lex_state = 41}, [1330] = {.lex_state = 9}, - [1331] = {.lex_state = 41}, - [1332] = {.lex_state = 41}, + [1331] = {.lex_state = 8}, + [1332] = {.lex_state = 8}, [1333] = {.lex_state = 41}, - [1334] = {.lex_state = 41}, + [1334] = {.lex_state = 16, .external_lex_state = 3}, [1335] = {.lex_state = 41}, - [1336] = {.lex_state = 9}, - [1337] = {.lex_state = 8}, + [1336] = {.lex_state = 8}, + [1337] = {.lex_state = 41, .external_lex_state = 3}, [1338] = {.lex_state = 41}, - [1339] = {.lex_state = 41}, - [1340] = {.lex_state = 41}, - [1341] = {.lex_state = 16}, - [1342] = {.lex_state = 8}, - [1343] = {.lex_state = 8}, - [1344] = {.lex_state = 41}, + [1339] = {.lex_state = 8}, + [1340] = {.lex_state = 41, .external_lex_state = 3}, + [1341] = {.lex_state = 8}, + [1342] = {.lex_state = 41}, + [1343] = {.lex_state = 41}, + [1344] = {.lex_state = 8}, [1345] = {.lex_state = 41}, - [1346] = {.lex_state = 41, .external_lex_state = 3}, + [1346] = {.lex_state = 8}, [1347] = {.lex_state = 41}, - [1348] = {.lex_state = 16}, + [1348] = {.lex_state = 8}, [1349] = {.lex_state = 41}, [1350] = {.lex_state = 41}, [1351] = {.lex_state = 41}, [1352] = {.lex_state = 41}, - [1353] = {.lex_state = 41, .external_lex_state = 3}, + [1353] = {.lex_state = 8}, [1354] = {.lex_state = 41}, - [1355] = {.lex_state = 16, .external_lex_state = 3}, + [1355] = {.lex_state = 41}, [1356] = {.lex_state = 41}, [1357] = {.lex_state = 41}, [1358] = {.lex_state = 8}, [1359] = {.lex_state = 41}, [1360] = {.lex_state = 41}, - [1361] = {.lex_state = 41}, - [1362] = {.lex_state = 9}, - [1363] = {.lex_state = 41}, - [1364] = {.lex_state = 41, .external_lex_state = 3}, - [1365] = {.lex_state = 8}, + [1361] = {.lex_state = 16}, + [1362] = {.lex_state = 8}, + [1363] = {.lex_state = 8}, + [1364] = {.lex_state = 41}, + [1365] = {.lex_state = 41}, [1366] = {.lex_state = 41}, [1367] = {.lex_state = 41}, [1368] = {.lex_state = 41}, [1369] = {.lex_state = 41}, [1370] = {.lex_state = 41}, [1371] = {.lex_state = 41}, - [1372] = {.lex_state = 41, .external_lex_state = 3}, + [1372] = {.lex_state = 41}, [1373] = {.lex_state = 41}, - [1374] = {.lex_state = 41}, - [1375] = {.lex_state = 16}, - [1376] = {.lex_state = 41, .external_lex_state = 3}, - [1377] = {.lex_state = 41}, - [1378] = {.lex_state = 41, .external_lex_state = 3}, - [1379] = {.lex_state = 16}, + [1374] = {.lex_state = 41, .external_lex_state = 3}, + [1375] = {.lex_state = 41}, + [1376] = {.lex_state = 41}, + [1377] = {.lex_state = 41, .external_lex_state = 3}, + [1378] = {.lex_state = 41}, + [1379] = {.lex_state = 41, .external_lex_state = 3}, [1380] = {.lex_state = 41}, [1381] = {.lex_state = 41}, [1382] = {.lex_state = 41}, - [1383] = {.lex_state = 41}, - [1384] = {.lex_state = 41, .external_lex_state = 3}, + [1383] = {.lex_state = 41, .external_lex_state = 3}, + [1384] = {.lex_state = 41}, [1385] = {.lex_state = 41}, - [1386] = {.lex_state = 16}, - [1387] = {.lex_state = 41}, - [1388] = {.lex_state = 41, .external_lex_state = 3}, - [1389] = {.lex_state = 41, .external_lex_state = 3}, - [1390] = {.lex_state = 41, .external_lex_state = 3}, + [1386] = {.lex_state = 8}, + [1387] = {.lex_state = 41, .external_lex_state = 3}, + [1388] = {.lex_state = 41}, + [1389] = {.lex_state = 16}, + [1390] = {.lex_state = 41}, [1391] = {.lex_state = 41}, [1392] = {.lex_state = 41}, - [1393] = {.lex_state = 41}, - [1394] = {.lex_state = 41}, - [1395] = {.lex_state = 41}, - [1396] = {.lex_state = 41, .external_lex_state = 3}, + [1393] = {.lex_state = 16}, + [1394] = {.lex_state = 8}, + [1395] = {.lex_state = 8}, + [1396] = {.lex_state = 16}, [1397] = {.lex_state = 41, .external_lex_state = 3}, [1398] = {.lex_state = 41}, [1399] = {.lex_state = 8}, - [1400] = {.lex_state = 41, .external_lex_state = 3}, - [1401] = {.lex_state = 41, .external_lex_state = 3}, + [1400] = {.lex_state = 41}, + [1401] = {.lex_state = 41}, [1402] = {.lex_state = 41}, [1403] = {.lex_state = 41}, - [1404] = {.lex_state = 16}, - [1405] = {.lex_state = 8}, - [1406] = {.lex_state = 41}, - [1407] = {.lex_state = 41}, - [1408] = {.lex_state = 41, .external_lex_state = 3}, - [1409] = {.lex_state = 16}, + [1404] = {.lex_state = 41}, + [1405] = {.lex_state = 41}, + [1406] = {.lex_state = 41, .external_lex_state = 3}, + [1407] = {.lex_state = 41, .external_lex_state = 3}, + [1408] = {.lex_state = 41}, + [1409] = {.lex_state = 41, .external_lex_state = 3}, [1410] = {.lex_state = 41, .external_lex_state = 3}, [1411] = {.lex_state = 41, .external_lex_state = 3}, - [1412] = {.lex_state = 41, .external_lex_state = 3}, - [1413] = {.lex_state = 8}, - [1414] = {.lex_state = 41, .external_lex_state = 3}, - [1415] = {.lex_state = 41, .external_lex_state = 3}, - [1416] = {.lex_state = 16}, + [1412] = {.lex_state = 41}, + [1413] = {.lex_state = 41}, + [1414] = {.lex_state = 16}, + [1415] = {.lex_state = 8}, + [1416] = {.lex_state = 41}, [1417] = {.lex_state = 41}, - [1418] = {.lex_state = 41, .external_lex_state = 3}, - [1419] = {.lex_state = 41}, + [1418] = {.lex_state = 41}, + [1419] = {.lex_state = 41, .external_lex_state = 3}, [1420] = {.lex_state = 41, .external_lex_state = 3}, - [1421] = {.lex_state = 41}, - [1422] = {.lex_state = 41}, - [1423] = {.lex_state = 41}, + [1421] = {.lex_state = 41, .external_lex_state = 3}, + [1422] = {.lex_state = 16}, + [1423] = {.lex_state = 41, .external_lex_state = 3}, [1424] = {.lex_state = 41}, [1425] = {.lex_state = 41}, - [1426] = {.lex_state = 8}, - [1427] = {.lex_state = 41}, - [1428] = {.lex_state = 16}, + [1426] = {.lex_state = 16}, + [1427] = {.lex_state = 41, .external_lex_state = 3}, + [1428] = {.lex_state = 41, .external_lex_state = 3}, [1429] = {.lex_state = 41, .external_lex_state = 3}, [1430] = {.lex_state = 41}, [1431] = {.lex_state = 41}, [1432] = {.lex_state = 41}, - [1433] = {.lex_state = 41}, + [1433] = {.lex_state = 41, .external_lex_state = 3}, [1434] = {.lex_state = 41, .external_lex_state = 3}, [1435] = {.lex_state = 41}, [1436] = {.lex_state = 41, .external_lex_state = 3}, - [1437] = {.lex_state = 41, .external_lex_state = 3}, - [1438] = {.lex_state = 8}, + [1437] = {.lex_state = 41}, + [1438] = {.lex_state = 16}, [1439] = {.lex_state = 16}, [1440] = {.lex_state = 41}, - [1441] = {.lex_state = 41, .external_lex_state = 3}, + [1441] = {.lex_state = 41}, [1442] = {.lex_state = 41}, [1443] = {.lex_state = 41}, - [1444] = {.lex_state = 8}, - [1445] = {.lex_state = 41}, - [1446] = {.lex_state = 41, .external_lex_state = 3}, - [1447] = {.lex_state = 41, .external_lex_state = 3}, - [1448] = {.lex_state = 41}, - [1449] = {.lex_state = 41}, - [1450] = {.lex_state = 41, .external_lex_state = 3}, - [1451] = {.lex_state = 16}, + [1444] = {.lex_state = 41, .external_lex_state = 3}, + [1445] = {.lex_state = 8}, + [1446] = {.lex_state = 41}, + [1447] = {.lex_state = 41}, + [1448] = {.lex_state = 41, .external_lex_state = 3}, + [1449] = {.lex_state = 41, .external_lex_state = 3}, + [1450] = {.lex_state = 41}, + [1451] = {.lex_state = 41}, [1452] = {.lex_state = 41}, [1453] = {.lex_state = 41}, - [1454] = {.lex_state = 41}, + [1454] = {.lex_state = 41, .external_lex_state = 3}, [1455] = {.lex_state = 41}, - [1456] = {.lex_state = 41}, - [1457] = {.lex_state = 41}, - [1458] = {.lex_state = 9}, + [1456] = {.lex_state = 41, .external_lex_state = 3}, + [1457] = {.lex_state = 41, .external_lex_state = 3}, + [1458] = {.lex_state = 41, .external_lex_state = 3}, [1459] = {.lex_state = 41}, - [1460] = {.lex_state = 41}, + [1460] = {.lex_state = 41, .external_lex_state = 3}, [1461] = {.lex_state = 41, .external_lex_state = 3}, - [1462] = {.lex_state = 41, .external_lex_state = 3}, - [1463] = {.lex_state = 41}, - [1464] = {.lex_state = 41, .external_lex_state = 3}, - [1465] = {.lex_state = 8}, + [1462] = {.lex_state = 41}, + [1463] = {.lex_state = 8}, + [1464] = {.lex_state = 41}, + [1465] = {.lex_state = 41}, [1466] = {.lex_state = 41}, [1467] = {.lex_state = 41}, - [1468] = {.lex_state = 41}, + [1468] = {.lex_state = 41, .external_lex_state = 3}, [1469] = {.lex_state = 41}, - [1470] = {.lex_state = 8}, + [1470] = {.lex_state = 16}, [1471] = {.lex_state = 41}, - [1472] = {.lex_state = 41}, + [1472] = {.lex_state = 41, .external_lex_state = 3}, [1473] = {.lex_state = 41}, [1474] = {.lex_state = 41}, - [1475] = {.lex_state = 41, .external_lex_state = 3}, - [1476] = {.lex_state = 41, .external_lex_state = 3}, - [1477] = {.lex_state = 41, .external_lex_state = 3}, + [1475] = {.lex_state = 41}, + [1476] = {.lex_state = 41}, + [1477] = {.lex_state = 41}, [1478] = {.lex_state = 8}, - [1479] = {.lex_state = 41}, + [1479] = {.lex_state = 41, .external_lex_state = 3}, [1480] = {.lex_state = 41}, [1481] = {.lex_state = 41}, [1482] = {.lex_state = 41}, - [1483] = {.lex_state = 41}, - [1484] = {.lex_state = 41, .external_lex_state = 3}, - [1485] = {.lex_state = 8}, - [1486] = {.lex_state = 16}, + [1483] = {.lex_state = 8}, + [1484] = {.lex_state = 8}, + [1485] = {.lex_state = 41}, + [1486] = {.lex_state = 41, .external_lex_state = 3}, [1487] = {.lex_state = 41}, [1488] = {.lex_state = 41, .external_lex_state = 3}, [1489] = {.lex_state = 41}, - [1490] = {.lex_state = 41}, - [1491] = {.lex_state = 41}, + [1490] = {.lex_state = 41, .external_lex_state = 3}, + [1491] = {.lex_state = 8}, [1492] = {.lex_state = 41}, [1493] = {.lex_state = 41}, - [1494] = {.lex_state = 41, .external_lex_state = 3}, + [1494] = {.lex_state = 41}, [1495] = {.lex_state = 41, .external_lex_state = 3}, [1496] = {.lex_state = 16}, - [1497] = {.lex_state = 41}, - [1498] = {.lex_state = 8}, + [1497] = {.lex_state = 41, .external_lex_state = 3}, + [1498] = {.lex_state = 41, .external_lex_state = 3}, [1499] = {.lex_state = 41}, [1500] = {.lex_state = 41}, [1501] = {.lex_state = 41}, - [1502] = {.lex_state = 8}, - [1503] = {.lex_state = 8}, + [1502] = {.lex_state = 41}, + [1503] = {.lex_state = 41, .external_lex_state = 3}, [1504] = {.lex_state = 41}, - [1505] = {.lex_state = 16}, - [1506] = {.lex_state = 41, .external_lex_state = 3}, - [1507] = {.lex_state = 16}, + [1505] = {.lex_state = 41, .external_lex_state = 3}, + [1506] = {.lex_state = 16}, + [1507] = {.lex_state = 41, .external_lex_state = 3}, [1508] = {.lex_state = 41}, - [1509] = {.lex_state = 41}, + [1509] = {.lex_state = 41, .external_lex_state = 3}, [1510] = {.lex_state = 41}, [1511] = {.lex_state = 41, .external_lex_state = 3}, - [1512] = {.lex_state = 41, .external_lex_state = 3}, - [1513] = {.lex_state = 41}, - [1514] = {.lex_state = 16}, - [1515] = {.lex_state = 41}, + [1512] = {.lex_state = 41}, + [1513] = {.lex_state = 41, .external_lex_state = 3}, + [1514] = {.lex_state = 41}, + [1515] = {.lex_state = 8}, [1516] = {.lex_state = 41}, [1517] = {.lex_state = 41}, - [1518] = {.lex_state = 16}, - [1519] = {.lex_state = 16}, - [1520] = {.lex_state = 41, .external_lex_state = 3}, - [1521] = {.lex_state = 41, .external_lex_state = 3}, - [1522] = {.lex_state = 16}, - [1523] = {.lex_state = 8}, - [1524] = {.lex_state = 41}, - [1525] = {.lex_state = 16}, - [1526] = {.lex_state = 41, .external_lex_state = 3}, + [1518] = {.lex_state = 41, .external_lex_state = 3}, + [1519] = {.lex_state = 41}, + [1520] = {.lex_state = 41}, + [1521] = {.lex_state = 16}, + [1522] = {.lex_state = 41, .external_lex_state = 3}, + [1523] = {.lex_state = 41}, + [1524] = {.lex_state = 16}, + [1525] = {.lex_state = 41}, + [1526] = {.lex_state = 41}, [1527] = {.lex_state = 41}, - [1528] = {.lex_state = 41}, + [1528] = {.lex_state = 16}, [1529] = {.lex_state = 16}, - [1530] = {.lex_state = 41}, - [1531] = {.lex_state = 41}, - [1532] = {.lex_state = 41, .external_lex_state = 3}, - [1533] = {.lex_state = 41}, + [1530] = {.lex_state = 41, .external_lex_state = 3}, + [1531] = {.lex_state = 41, .external_lex_state = 3}, + [1532] = {.lex_state = 16}, + [1533] = {.lex_state = 8}, [1534] = {.lex_state = 41}, - [1535] = {.lex_state = 41}, - [1536] = {.lex_state = 41, .external_lex_state = 3}, + [1535] = {.lex_state = 16}, + [1536] = {.lex_state = 16}, [1537] = {.lex_state = 41}, [1538] = {.lex_state = 41, .external_lex_state = 3}, - [1539] = {.lex_state = 41}, - [1540] = {.lex_state = 41}, + [1539] = {.lex_state = 16}, + [1540] = {.lex_state = 41, .external_lex_state = 3}, [1541] = {.lex_state = 41}, [1542] = {.lex_state = 41}, [1543] = {.lex_state = 41}, - [1544] = {.lex_state = 16}, - [1545] = {.lex_state = 41, .external_lex_state = 3}, + [1544] = {.lex_state = 41}, + [1545] = {.lex_state = 41}, [1546] = {.lex_state = 41}, - [1547] = {.lex_state = 41, .external_lex_state = 3}, + [1547] = {.lex_state = 41}, [1548] = {.lex_state = 41}, [1549] = {.lex_state = 41}, - [1550] = {.lex_state = 8}, - [1551] = {.lex_state = 41, .external_lex_state = 3}, + [1550] = {.lex_state = 41}, + [1551] = {.lex_state = 41}, [1552] = {.lex_state = 41}, - [1553] = {.lex_state = 41, .external_lex_state = 3}, + [1553] = {.lex_state = 41}, [1554] = {.lex_state = 41}, [1555] = {.lex_state = 41}, - [1556] = {.lex_state = 41, .external_lex_state = 3}, - [1557] = {.lex_state = 41}, - [1558] = {.lex_state = 41, .external_lex_state = 3}, - [1559] = {.lex_state = 41}, - [1560] = {.lex_state = 16}, - [1561] = {.lex_state = 41, .external_lex_state = 3}, + [1556] = {.lex_state = 41}, + [1557] = {.lex_state = 41, .external_lex_state = 3}, + [1558] = {.lex_state = 41}, + [1559] = {.lex_state = 41, .external_lex_state = 3}, + [1560] = {.lex_state = 8}, + [1561] = {.lex_state = 41}, [1562] = {.lex_state = 41}, - [1563] = {.lex_state = 41, .external_lex_state = 3}, - [1564] = {.lex_state = 9}, - [1565] = {.lex_state = 41}, - [1566] = {.lex_state = 41}, + [1563] = {.lex_state = 41}, + [1564] = {.lex_state = 8}, + [1565] = {.lex_state = 41, .external_lex_state = 3}, + [1566] = {.lex_state = 41, .external_lex_state = 3}, [1567] = {.lex_state = 41}, [1568] = {.lex_state = 41}, [1569] = {.lex_state = 41}, [1570] = {.lex_state = 41}, - [1571] = {.lex_state = 41}, + [1571] = {.lex_state = 41, .external_lex_state = 3}, [1572] = {.lex_state = 41}, [1573] = {.lex_state = 41}, - [1574] = {.lex_state = 41, .external_lex_state = 3}, + [1574] = {.lex_state = 9}, [1575] = {.lex_state = 41}, [1576] = {.lex_state = 41}, [1577] = {.lex_state = 41}, - [1578] = {.lex_state = 41}, - [1579] = {.lex_state = 41, .external_lex_state = 3}, - [1580] = {.lex_state = 41, .external_lex_state = 3}, - [1581] = {.lex_state = 41, .external_lex_state = 3}, + [1578] = {.lex_state = 41, .external_lex_state = 3}, + [1579] = {.lex_state = 41}, + [1580] = {.lex_state = 41}, + [1581] = {.lex_state = 41}, [1582] = {.lex_state = 41}, - [1583] = {.lex_state = 41}, - [1584] = {.lex_state = 41}, - [1585] = {.lex_state = 41}, - [1586] = {.lex_state = 8}, + [1583] = {.lex_state = 41, .external_lex_state = 3}, + [1584] = {.lex_state = 41, .external_lex_state = 3}, + [1585] = {.lex_state = 41, .external_lex_state = 3}, + [1586] = {.lex_state = 41}, [1587] = {.lex_state = 41}, [1588] = {.lex_state = 41, .external_lex_state = 3}, [1589] = {.lex_state = 41}, [1590] = {.lex_state = 41}, - [1591] = {.lex_state = 41, .external_lex_state = 3}, + [1591] = {.lex_state = 8}, [1592] = {.lex_state = 41}, [1593] = {.lex_state = 41, .external_lex_state = 3}, [1594] = {.lex_state = 41}, [1595] = {.lex_state = 41}, - [1596] = {.lex_state = 41, .external_lex_state = 3}, + [1596] = {.lex_state = 8}, [1597] = {.lex_state = 41}, - [1598] = {.lex_state = 41, .external_lex_state = 3}, - [1599] = {.lex_state = 16}, + [1598] = {.lex_state = 41}, + [1599] = {.lex_state = 41}, [1600] = {.lex_state = 41}, - [1601] = {.lex_state = 41}, + [1601] = {.lex_state = 41, .external_lex_state = 3}, [1602] = {.lex_state = 41}, - [1603] = {.lex_state = 41}, + [1603] = {.lex_state = 41, .external_lex_state = 3}, [1604] = {.lex_state = 41}, [1605] = {.lex_state = 41}, [1606] = {.lex_state = 41}, [1607] = {.lex_state = 41}, [1608] = {.lex_state = 41}, - [1609] = {.lex_state = 41}, + [1609] = {.lex_state = 41, .external_lex_state = 3}, [1610] = {.lex_state = 41}, - [1611] = {.lex_state = 8}, - [1612] = {.lex_state = 41}, - [1613] = {.lex_state = 41}, - [1614] = {.lex_state = 41, .external_lex_state = 3}, + [1611] = {.lex_state = 41, .external_lex_state = 3}, + [1612] = {.lex_state = 16}, + [1613] = {.lex_state = 41, .external_lex_state = 3}, + [1614] = {.lex_state = 41}, [1615] = {.lex_state = 41}, [1616] = {.lex_state = 41}, - [1617] = {.lex_state = 8}, + [1617] = {.lex_state = 41}, [1618] = {.lex_state = 41}, - [1619] = {.lex_state = 41}, + [1619] = {.lex_state = 8}, [1620] = {.lex_state = 41}, - [1621] = {.lex_state = 41}, - [1622] = {.lex_state = 8}, - [1623] = {.lex_state = 41}, - [1624] = {.lex_state = 41}, + [1621] = {.lex_state = 8}, + [1622] = {.lex_state = 41}, + [1623] = {.lex_state = 9}, + [1624] = {.lex_state = 41, .external_lex_state = 3}, [1625] = {.lex_state = 41}, [1626] = {.lex_state = 41}, [1627] = {.lex_state = 41}, - [1628] = {.lex_state = 41, .external_lex_state = 3}, + [1628] = {.lex_state = 41}, [1629] = {.lex_state = 41}, - [1630] = {.lex_state = 41}, - [1631] = {.lex_state = 41}, + [1630] = {.lex_state = 16}, + [1631] = {.lex_state = 41, .external_lex_state = 3}, [1632] = {.lex_state = 41}, [1633] = {.lex_state = 41}, - [1634] = {.lex_state = 8}, - [1635] = {.lex_state = 41, .external_lex_state = 3}, + [1634] = {.lex_state = 41}, + [1635] = {.lex_state = 41}, [1636] = {.lex_state = 41, .external_lex_state = 3}, [1637] = {.lex_state = 41, .external_lex_state = 3}, - [1638] = {.lex_state = 41}, - [1639] = {.lex_state = 41}, - [1640] = {.lex_state = 41, .external_lex_state = 3}, - [1641] = {.lex_state = 41}, + [1638] = {.lex_state = 41, .external_lex_state = 3}, + [1639] = {.lex_state = 41, .external_lex_state = 3}, + [1640] = {.lex_state = 41}, + [1641] = {.lex_state = 41, .external_lex_state = 3}, [1642] = {.lex_state = 41}, - [1643] = {.lex_state = 41, .external_lex_state = 3}, - [1644] = {.lex_state = 9}, + [1643] = {.lex_state = 41}, + [1644] = {.lex_state = 8}, [1645] = {.lex_state = 41}, - [1646] = {.lex_state = 41}, + [1646] = {.lex_state = 41, .external_lex_state = 3}, [1647] = {.lex_state = 41}, [1648] = {.lex_state = 41}, - [1649] = {.lex_state = 41, .external_lex_state = 3}, - [1650] = {.lex_state = 41, .external_lex_state = 3}, + [1649] = {.lex_state = 41}, + [1650] = {.lex_state = 41}, [1651] = {.lex_state = 41, .external_lex_state = 3}, [1652] = {.lex_state = 41}, - [1653] = {.lex_state = 41, .external_lex_state = 3}, - [1654] = {.lex_state = 41}, + [1653] = {.lex_state = 41}, + [1654] = {.lex_state = 9}, [1655] = {.lex_state = 41}, [1656] = {.lex_state = 41}, [1657] = {.lex_state = 41}, - [1658] = {.lex_state = 41}, + [1658] = {.lex_state = 41, .external_lex_state = 3}, [1659] = {.lex_state = 41}, - [1660] = {.lex_state = 41}, - [1661] = {.lex_state = 41}, + [1660] = {.lex_state = 41, .external_lex_state = 3}, + [1661] = {.lex_state = 41, .external_lex_state = 3}, [1662] = {.lex_state = 41}, - [1663] = {.lex_state = 41}, - [1664] = {.lex_state = 41, .external_lex_state = 3}, + [1663] = {.lex_state = 41, .external_lex_state = 3}, + [1664] = {.lex_state = 41}, [1665] = {.lex_state = 41}, - [1666] = {.lex_state = 41}, + [1666] = {.lex_state = 16}, [1667] = {.lex_state = 41}, - [1668] = {.lex_state = 41, .external_lex_state = 3}, - [1669] = {.lex_state = 41, .external_lex_state = 3}, - [1670] = {.lex_state = 41}, + [1668] = {.lex_state = 41}, + [1669] = {.lex_state = 41}, + [1670] = {.lex_state = 41, .external_lex_state = 3}, [1671] = {.lex_state = 41}, - [1672] = {.lex_state = 41, .external_lex_state = 3}, + [1672] = {.lex_state = 41}, [1673] = {.lex_state = 41}, - [1674] = {.lex_state = 41}, + [1674] = {.lex_state = 41, .external_lex_state = 3}, [1675] = {.lex_state = 41}, [1676] = {.lex_state = 41}, [1677] = {.lex_state = 41}, - [1678] = {.lex_state = 41, .external_lex_state = 3}, + [1678] = {.lex_state = 41}, [1679] = {.lex_state = 41}, [1680] = {.lex_state = 41}, [1681] = {.lex_state = 41}, [1682] = {.lex_state = 41}, [1683] = {.lex_state = 41}, - [1684] = {.lex_state = 41, .external_lex_state = 3}, - [1685] = {.lex_state = 41, .external_lex_state = 3}, + [1684] = {.lex_state = 41}, + [1685] = {.lex_state = 41}, [1686] = {.lex_state = 41}, [1687] = {.lex_state = 41}, - [1688] = {.lex_state = 41, .external_lex_state = 3}, - [1689] = {.lex_state = 41}, + [1688] = {.lex_state = 41}, + [1689] = {.lex_state = 16}, [1690] = {.lex_state = 41}, [1691] = {.lex_state = 41}, - [1692] = {.lex_state = 8}, + [1692] = {.lex_state = 16}, [1693] = {.lex_state = 41}, - [1694] = {.lex_state = 41}, + [1694] = {.lex_state = 41, .external_lex_state = 3}, [1695] = {.lex_state = 41}, [1696] = {.lex_state = 41}, [1697] = {.lex_state = 41}, - [1698] = {.lex_state = 8}, - [1699] = {.lex_state = 8}, + [1698] = {.lex_state = 41}, + [1699] = {.lex_state = 41}, [1700] = {.lex_state = 41}, - [1701] = {.lex_state = 8}, - [1702] = {.lex_state = 41}, - [1703] = {.lex_state = 41}, + [1701] = {.lex_state = 41}, + [1702] = {.lex_state = 8}, + [1703] = {.lex_state = 41, .external_lex_state = 3}, [1704] = {.lex_state = 41}, [1705] = {.lex_state = 41}, [1706] = {.lex_state = 41}, [1707] = {.lex_state = 41}, - [1708] = {.lex_state = 16}, - [1709] = {.lex_state = 41}, + [1708] = {.lex_state = 8}, + [1709] = {.lex_state = 8}, [1710] = {.lex_state = 41}, - [1711] = {.lex_state = 41}, + [1711] = {.lex_state = 8}, [1712] = {.lex_state = 41}, - [1713] = {.lex_state = 41}, + [1713] = {.lex_state = 41, .external_lex_state = 3}, [1714] = {.lex_state = 41}, [1715] = {.lex_state = 41}, - [1716] = {.lex_state = 41}, - [1717] = {.lex_state = 41, .external_lex_state = 3}, - [1718] = {.lex_state = 41, .external_lex_state = 3}, + [1716] = {.lex_state = 41, .external_lex_state = 3}, + [1717] = {.lex_state = 41}, + [1718] = {.lex_state = 9}, [1719] = {.lex_state = 41}, [1720] = {.lex_state = 41}, - [1721] = {.lex_state = 41}, + [1721] = {.lex_state = 41, .external_lex_state = 3}, [1722] = {.lex_state = 41}, [1723] = {.lex_state = 41}, [1724] = {.lex_state = 41}, [1725] = {.lex_state = 41}, - [1726] = {.lex_state = 16}, - [1727] = {.lex_state = 8}, - [1728] = {.lex_state = 41, .external_lex_state = 3}, - [1729] = {.lex_state = 41}, - [1730] = {.lex_state = 8}, - [1731] = {.lex_state = 41, .external_lex_state = 3}, - [1732] = {.lex_state = 16}, + [1726] = {.lex_state = 41}, + [1727] = {.lex_state = 41, .external_lex_state = 3}, + [1728] = {.lex_state = 41}, + [1729] = {.lex_state = 16}, + [1730] = {.lex_state = 41}, + [1731] = {.lex_state = 41}, + [1732] = {.lex_state = 41}, [1733] = {.lex_state = 41, .external_lex_state = 3}, - [1734] = {.lex_state = 41}, - [1735] = {.lex_state = 41, .external_lex_state = 3}, + [1734] = {.lex_state = 41, .external_lex_state = 3}, + [1735] = {.lex_state = 41}, [1736] = {.lex_state = 41}, - [1737] = {.lex_state = 41}, - [1738] = {.lex_state = 41}, - [1739] = {.lex_state = 41, .external_lex_state = 3}, - [1740] = {.lex_state = 41, .external_lex_state = 3}, + [1737] = {.lex_state = 8}, + [1738] = {.lex_state = 41, .external_lex_state = 3}, + [1739] = {.lex_state = 41}, + [1740] = {.lex_state = 8}, [1741] = {.lex_state = 41}, [1742] = {.lex_state = 41, .external_lex_state = 3}, [1743] = {.lex_state = 41}, - [1744] = {.lex_state = 41}, + [1744] = {.lex_state = 8}, [1745] = {.lex_state = 41}, - [1746] = {.lex_state = 41, .external_lex_state = 3}, + [1746] = {.lex_state = 41}, [1747] = {.lex_state = 41}, - [1748] = {.lex_state = 8}, - [1749] = {.lex_state = 16}, + [1748] = {.lex_state = 41}, + [1749] = {.lex_state = 41}, [1750] = {.lex_state = 41, .external_lex_state = 3}, + [1751] = {.lex_state = 16}, + [1752] = {.lex_state = 41}, + [1753] = {.lex_state = 41}, + [1754] = {.lex_state = 41}, + [1755] = {.lex_state = 41}, + [1756] = {.lex_state = 8}, + [1757] = {.lex_state = 41}, + [1758] = {.lex_state = 41}, + [1759] = {.lex_state = 41}, + [1760] = {.lex_state = 41, .external_lex_state = 3}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -7366,6 +7431,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_if] = ACTIONS(1), [anon_sym_else] = ACTIONS(1), [anon_sym_handle] = ACTIONS(1), + [anon_sym_do] = ACTIONS(1), [anon_sym_kernel] = ACTIONS(1), [anon_sym_select] = ACTIONS(1), [anon_sym_QMARK] = ACTIONS(1), @@ -7410,51 +7476,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__statement_break] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(1430), + [sym_source_file] = STATE(1650), [sym_statement] = STATE(7), - [sym_import_statement] = STATE(1477), - [sym_namespace_declaration] = STATE(1477), - [sym_let_declaration] = STATE(1477), - [sym_assignment] = STATE(1477), - [sym_function_declaration] = STATE(1477), - [sym_extern_declaration] = STATE(1477), - [sym_type_declaration] = STATE(1477), - [sym_effect_declaration] = STATE(1477), - [sym_expression_statement] = STATE(1477), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1477), - [sym_signature_declaration] = STATE(1477), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1379), + [sym_namespace_declaration] = STATE(1379), + [sym_let_declaration] = STATE(1379), + [sym_assignment] = STATE(1379), + [sym_function_declaration] = STATE(1379), + [sym_extern_declaration] = STATE(1379), + [sym_type_declaration] = STATE(1379), + [sym_effect_declaration] = STATE(1379), + [sym_expression_statement] = STATE(1379), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1379), + [sym_signature_declaration] = STATE(1379), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(7), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), [ts_builtin_sym_end] = ACTIONS(5), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), @@ -7498,53 +7564,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [2] = { - [sym_statement] = STATE(11), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(452), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_field_assignments] = STATE(1499), - [sym_field_assignment] = STATE(1130), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_map_entry] = STATE(1173), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_statement] = STATE(14), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(467), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_field_assignments] = STATE(1590), + [sym_field_assignment] = STATE(1132), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_map_entry] = STATE(1210), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(11), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(14), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7588,53 +7654,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [3] = { - [sym_statement] = STATE(6), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(440), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_field_assignments] = STATE(1693), - [sym_field_assignment] = STATE(1130), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_map_entry] = STATE(1132), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_statement] = STATE(17), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(462), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_field_assignments] = STATE(1492), + [sym_field_assignment] = STATE(1132), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_map_entry] = STATE(1129), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(6), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(17), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7678,53 +7744,53 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [4] = { - [sym_statement] = STATE(15), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(463), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_field_assignments] = STATE(1482), - [sym_field_assignment] = STATE(1130), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_map_entry] = STATE(1174), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_statement] = STATE(8), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(445), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_field_assignments] = STATE(1625), + [sym_field_assignment] = STATE(1132), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_map_entry] = STATE(1254), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(15), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(8), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(73), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -7768,35 +7834,35 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [5] = { - [sym_expression] = STATE(333), - [sym_match_expression] = STATE(386), - [sym_if_expression] = STATE(386), - [sym_handler_expression] = STATE(386), - [sym_kernel_expression] = STATE(386), - [sym_select_expression] = STATE(386), - [sym_ternary_expression] = STATE(386), - [sym_binary_expression] = STATE(386), - [sym_unary_expression] = STATE(386), - [sym_pipe_expression] = STATE(386), - [sym_call_expression] = STATE(386), - [sym_primary_expression] = STATE(386), - [sym_spawn_expression] = STATE(391), - [sym_yield_expression] = STATE(391), - [sym_await_call] = STATE(391), - [sym_send_call] = STATE(391), - [sym_recv_call] = STATE(391), - [sym_perform_expression] = STATE(391), - [sym_resume_expression] = STATE(391), - [sym_type_constructor] = STATE(391), - [sym_update_expression] = STATE(391), - [sym_block] = STATE(391), - [sym_object_literal] = STATE(391), - [sym_lambda_expression] = STATE(391), - [sym_literal] = STATE(391), - [sym_list_literal] = STATE(381), - [sym_map_literal] = STATE(381), - [sym_qualified_path] = STATE(329), - [sym_boolean] = STATE(381), + [sym_expression] = STATE(334), + [sym_match_expression] = STATE(377), + [sym_if_expression] = STATE(377), + [sym_handler_expression] = STATE(377), + [sym_kernel_expression] = STATE(377), + [sym_select_expression] = STATE(377), + [sym_ternary_expression] = STATE(377), + [sym_binary_expression] = STATE(377), + [sym_unary_expression] = STATE(377), + [sym_pipe_expression] = STATE(377), + [sym_call_expression] = STATE(377), + [sym_primary_expression] = STATE(377), + [sym_spawn_expression] = STATE(382), + [sym_yield_expression] = STATE(382), + [sym_await_call] = STATE(382), + [sym_send_call] = STATE(382), + [sym_recv_call] = STATE(382), + [sym_perform_expression] = STATE(382), + [sym_resume_expression] = STATE(382), + [sym_type_constructor] = STATE(382), + [sym_update_expression] = STATE(382), + [sym_block] = STATE(382), + [sym_object_literal] = STATE(382), + [sym_lambda_expression] = STATE(382), + [sym_literal] = STATE(382), + [sym_list_literal] = STATE(393), + [sym_map_literal] = STATE(393), + [sym_qualified_path] = STATE(330), + [sym_boolean] = STATE(393), [sym_identifier] = ACTIONS(81), [anon_sym_DOT] = ACTIONS(83), [anon_sym_LBRACE] = ACTIONS(85), @@ -7856,54 +7922,141 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__call_open_gap] = ACTIONS(83), }, [6] = { - [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(504), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_statement] = STATE(6), + [sym_import_statement] = STATE(1379), + [sym_namespace_declaration] = STATE(1379), + [sym_let_declaration] = STATE(1379), + [sym_assignment] = STATE(1379), + [sym_function_declaration] = STATE(1379), + [sym_extern_declaration] = STATE(1379), + [sym_type_declaration] = STATE(1379), + [sym_effect_declaration] = STATE(1379), + [sym_expression_statement] = STATE(1379), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1379), + [sym_signature_declaration] = STATE(1379), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(6), + [aux_sym_doc_comment_repeat1] = STATE(227), + [ts_builtin_sym_end] = ACTIONS(131), + [sym_identifier] = ACTIONS(133), + [anon_sym_import] = ACTIONS(136), + [anon_sym_LBRACE] = ACTIONS(139), + [anon_sym_namespace] = ACTIONS(142), + [anon_sym_let] = ACTIONS(145), + [anon_sym_mut] = ACTIONS(145), + [anon_sym_fn] = ACTIONS(148), + [anon_sym_LPAREN] = ACTIONS(151), + [anon_sym_extern] = ACTIONS(154), + [anon_sym_type] = ACTIONS(157), + [anon_sym_PIPE] = ACTIONS(160), + [sym_static_stage] = ACTIONS(163), + [anon_sym_effect] = ACTIONS(166), + [anon_sym_BANG] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(172), + [anon_sym_match] = ACTIONS(175), + [anon_sym_if] = ACTIONS(178), + [anon_sym_handle] = ACTIONS(181), + [anon_sym_kernel] = ACTIONS(184), + [anon_sym_select] = ACTIONS(187), + [anon_sym_PLUS] = ACTIONS(169), + [anon_sym_DASH] = ACTIONS(169), + [anon_sym_await] = ACTIONS(190), + [anon_sym_spawn] = ACTIONS(193), + [anon_sym_yield] = ACTIONS(196), + [anon_sym_send] = ACTIONS(199), + [anon_sym_recv] = ACTIONS(202), + [anon_sym_perform] = ACTIONS(205), + [anon_sym_resume] = ACTIONS(208), + [anon_sym_state] = ACTIONS(211), + [anon_sym_module] = ACTIONS(214), + [anon_sym_signature] = ACTIONS(217), + [anon_sym_true] = ACTIONS(220), + [anon_sym_false] = ACTIONS(220), + [sym_float] = ACTIONS(223), + [sym_integer] = ACTIONS(226), + [sym_string] = ACTIONS(226), + [sym_interpolated_string] = ACTIONS(226), + [sym__doc_comment_line] = ACTIONS(229), + [sym_line_comment] = ACTIONS(3), + }, + [7] = { + [sym_statement] = STATE(6), + [sym_import_statement] = STATE(1379), + [sym_namespace_declaration] = STATE(1379), + [sym_let_declaration] = STATE(1379), + [sym_assignment] = STATE(1379), + [sym_function_declaration] = STATE(1379), + [sym_extern_declaration] = STATE(1379), + [sym_type_declaration] = STATE(1379), + [sym_effect_declaration] = STATE(1379), + [sym_expression_statement] = STATE(1379), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1379), + [sym_signature_declaration] = STATE(1379), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), + [sym_doc_comment] = STATE(20), + [aux_sym_source_file_repeat1] = STATE(6), + [aux_sym_doc_comment_repeat1] = STATE(227), + [ts_builtin_sym_end] = ACTIONS(232), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(131), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -7942,55 +8095,55 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [7] = { - [sym_statement] = STATE(16), - [sym_import_statement] = STATE(1477), - [sym_namespace_declaration] = STATE(1477), - [sym_let_declaration] = STATE(1477), - [sym_assignment] = STATE(1477), - [sym_function_declaration] = STATE(1477), - [sym_extern_declaration] = STATE(1477), - [sym_type_declaration] = STATE(1477), - [sym_effect_declaration] = STATE(1477), - [sym_expression_statement] = STATE(1477), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1477), - [sym_signature_declaration] = STATE(1477), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [8] = { + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(522), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(16), - [aux_sym_doc_comment_repeat1] = STATE(226), - [ts_builtin_sym_end] = ACTIONS(133), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_RBRACE] = ACTIONS(234), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8029,55 +8182,142 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [8] = { + [9] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), + [sym_identifier] = ACTIONS(133), + [anon_sym_import] = ACTIONS(136), + [anon_sym_LBRACE] = ACTIONS(139), + [anon_sym_RBRACE] = ACTIONS(131), + [anon_sym_namespace] = ACTIONS(142), + [anon_sym_let] = ACTIONS(145), + [anon_sym_mut] = ACTIONS(145), + [anon_sym_fn] = ACTIONS(148), + [anon_sym_LPAREN] = ACTIONS(151), + [anon_sym_extern] = ACTIONS(154), + [anon_sym_type] = ACTIONS(157), + [anon_sym_PIPE] = ACTIONS(160), + [sym_static_stage] = ACTIONS(163), + [anon_sym_effect] = ACTIONS(166), + [anon_sym_BANG] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(172), + [anon_sym_match] = ACTIONS(175), + [anon_sym_if] = ACTIONS(178), + [anon_sym_handle] = ACTIONS(181), + [anon_sym_kernel] = ACTIONS(184), + [anon_sym_select] = ACTIONS(187), + [anon_sym_PLUS] = ACTIONS(169), + [anon_sym_DASH] = ACTIONS(169), + [anon_sym_await] = ACTIONS(190), + [anon_sym_spawn] = ACTIONS(193), + [anon_sym_yield] = ACTIONS(196), + [anon_sym_send] = ACTIONS(199), + [anon_sym_recv] = ACTIONS(202), + [anon_sym_perform] = ACTIONS(205), + [anon_sym_resume] = ACTIONS(208), + [anon_sym_state] = ACTIONS(211), + [anon_sym_module] = ACTIONS(214), + [anon_sym_signature] = ACTIONS(217), + [anon_sym_true] = ACTIONS(220), + [anon_sym_false] = ACTIONS(220), + [sym_float] = ACTIONS(223), + [sym_integer] = ACTIONS(226), + [sym_string] = ACTIONS(226), + [sym_interpolated_string] = ACTIONS(226), + [sym__doc_comment_line] = ACTIONS(229), + [sym_line_comment] = ACTIONS(3), + }, + [10] = { + [sym_statement] = STATE(11), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), + [sym_doc_comment] = STATE(20), + [aux_sym_source_file_repeat1] = STATE(11), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), - [anon_sym_RBRACE] = ACTIONS(135), + [anon_sym_RBRACE] = ACTIONS(236), [anon_sym_namespace] = ACTIONS(13), [anon_sym_let] = ACTIONS(15), [anon_sym_mut] = ACTIONS(15), @@ -8116,138 +8356,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [9] = { + [11] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(610), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), - [sym_identifier] = ACTIONS(137), - [anon_sym_import] = ACTIONS(140), - [anon_sym_LBRACE] = ACTIONS(143), - [anon_sym_RBRACE] = ACTIONS(146), - [anon_sym_namespace] = ACTIONS(148), - [anon_sym_let] = ACTIONS(151), - [anon_sym_mut] = ACTIONS(151), - [anon_sym_fn] = ACTIONS(154), - [anon_sym_LPAREN] = ACTIONS(157), - [anon_sym_extern] = ACTIONS(160), - [anon_sym_type] = ACTIONS(163), - [anon_sym_PIPE] = ACTIONS(166), - [sym_static_stage] = ACTIONS(169), - [anon_sym_effect] = ACTIONS(172), - [anon_sym_BANG] = ACTIONS(175), - [anon_sym_LBRACK] = ACTIONS(178), - [anon_sym_match] = ACTIONS(181), - [anon_sym_if] = ACTIONS(184), - [anon_sym_handle] = ACTIONS(187), - [anon_sym_kernel] = ACTIONS(190), - [anon_sym_select] = ACTIONS(193), - [anon_sym_PLUS] = ACTIONS(175), - [anon_sym_DASH] = ACTIONS(175), - [anon_sym_await] = ACTIONS(196), - [anon_sym_spawn] = ACTIONS(199), - [anon_sym_yield] = ACTIONS(202), - [anon_sym_send] = ACTIONS(205), - [anon_sym_recv] = ACTIONS(208), - [anon_sym_perform] = ACTIONS(211), - [anon_sym_resume] = ACTIONS(214), - [anon_sym_state] = ACTIONS(217), - [anon_sym_module] = ACTIONS(220), - [anon_sym_signature] = ACTIONS(223), - [anon_sym_true] = ACTIONS(226), - [anon_sym_false] = ACTIONS(226), - [sym_float] = ACTIONS(229), - [sym_integer] = ACTIONS(232), - [sym_string] = ACTIONS(232), - [sym_interpolated_string] = ACTIONS(232), - [sym__doc_comment_line] = ACTIONS(235), - [sym_line_comment] = ACTIONS(3), - }, - [10] = { - [sym_statement] = STATE(13), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(489), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), - [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(13), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8290,51 +8443,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [11] = { - [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(507), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [12] = { + [sym_statement] = STATE(16), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(487), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(16), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8377,51 +8530,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [12] = { + [13] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(522), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(515), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8464,51 +8617,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [13] = { + [14] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(519), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(481), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8551,51 +8704,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [14] = { - [sym_statement] = STATE(12), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(511), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [15] = { + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(495), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(12), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8638,51 +8791,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [15] = { + [16] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(521), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(507), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8725,138 +8878,51 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(71), [sym_line_comment] = ACTIONS(3), }, - [16] = { - [sym_statement] = STATE(16), - [sym_import_statement] = STATE(1477), - [sym_namespace_declaration] = STATE(1477), - [sym_let_declaration] = STATE(1477), - [sym_assignment] = STATE(1477), - [sym_function_declaration] = STATE(1477), - [sym_extern_declaration] = STATE(1477), - [sym_type_declaration] = STATE(1477), - [sym_effect_declaration] = STATE(1477), - [sym_expression_statement] = STATE(1477), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1477), - [sym_signature_declaration] = STATE(1477), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), - [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(16), - [aux_sym_doc_comment_repeat1] = STATE(226), - [ts_builtin_sym_end] = ACTIONS(146), - [sym_identifier] = ACTIONS(137), - [anon_sym_import] = ACTIONS(140), - [anon_sym_LBRACE] = ACTIONS(143), - [anon_sym_namespace] = ACTIONS(148), - [anon_sym_let] = ACTIONS(151), - [anon_sym_mut] = ACTIONS(151), - [anon_sym_fn] = ACTIONS(154), - [anon_sym_LPAREN] = ACTIONS(157), - [anon_sym_extern] = ACTIONS(160), - [anon_sym_type] = ACTIONS(163), - [anon_sym_PIPE] = ACTIONS(166), - [sym_static_stage] = ACTIONS(169), - [anon_sym_effect] = ACTIONS(172), - [anon_sym_BANG] = ACTIONS(175), - [anon_sym_LBRACK] = ACTIONS(178), - [anon_sym_match] = ACTIONS(181), - [anon_sym_if] = ACTIONS(184), - [anon_sym_handle] = ACTIONS(187), - [anon_sym_kernel] = ACTIONS(190), - [anon_sym_select] = ACTIONS(193), - [anon_sym_PLUS] = ACTIONS(175), - [anon_sym_DASH] = ACTIONS(175), - [anon_sym_await] = ACTIONS(196), - [anon_sym_spawn] = ACTIONS(199), - [anon_sym_yield] = ACTIONS(202), - [anon_sym_send] = ACTIONS(205), - [anon_sym_recv] = ACTIONS(208), - [anon_sym_perform] = ACTIONS(211), - [anon_sym_resume] = ACTIONS(214), - [anon_sym_state] = ACTIONS(217), - [anon_sym_module] = ACTIONS(220), - [anon_sym_signature] = ACTIONS(223), - [anon_sym_true] = ACTIONS(226), - [anon_sym_false] = ACTIONS(226), - [sym_float] = ACTIONS(229), - [sym_integer] = ACTIONS(232), - [sym_string] = ACTIONS(232), - [sym_interpolated_string] = ACTIONS(232), - [sym__doc_comment_line] = ACTIONS(235), - [sym_line_comment] = ACTIONS(3), - }, [17] = { - [sym_statement] = STATE(8), - [sym_import_statement] = STATE(1688), - [sym_namespace_declaration] = STATE(1688), - [sym_let_declaration] = STATE(1688), - [sym_assignment] = STATE(1688), - [sym_function_declaration] = STATE(1688), - [sym_extern_declaration] = STATE(1688), - [sym_type_declaration] = STATE(1688), - [sym_effect_declaration] = STATE(1688), - [sym_expression_statement] = STATE(1688), - [sym_expression] = STATE(533), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_module_declaration] = STATE(1688), - [sym_signature_declaration] = STATE(1688), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_statement] = STATE(9), + [sym_import_statement] = STATE(1760), + [sym_namespace_declaration] = STATE(1760), + [sym_let_declaration] = STATE(1760), + [sym_assignment] = STATE(1760), + [sym_function_declaration] = STATE(1760), + [sym_extern_declaration] = STATE(1760), + [sym_type_declaration] = STATE(1760), + [sym_effect_declaration] = STATE(1760), + [sym_expression_statement] = STATE(1760), + [sym_expression] = STATE(513), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_module_declaration] = STATE(1760), + [sym_signature_declaration] = STATE(1760), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), - [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(226), + [aux_sym_source_file_repeat1] = STATE(9), + [aux_sym_doc_comment_repeat1] = STATE(227), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), [anon_sym_LBRACE] = ACTIONS(11), @@ -8900,34 +8966,34 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [18] = { - [sym_expression] = STATE(245), - [sym_match_expression] = STATE(258), - [sym_if_expression] = STATE(258), - [sym_handler_expression] = STATE(258), - [sym_kernel_expression] = STATE(258), - [sym_select_expression] = STATE(258), - [sym_ternary_expression] = STATE(258), - [sym_binary_expression] = STATE(258), - [sym_unary_expression] = STATE(258), - [sym_pipe_expression] = STATE(258), - [sym_call_expression] = STATE(258), - [sym_primary_expression] = STATE(258), - [sym_spawn_expression] = STATE(259), - [sym_yield_expression] = STATE(259), - [sym_await_call] = STATE(259), - [sym_send_call] = STATE(259), - [sym_recv_call] = STATE(259), - [sym_perform_expression] = STATE(259), - [sym_resume_expression] = STATE(259), - [sym_type_constructor] = STATE(259), - [sym_update_expression] = STATE(259), - [sym_block] = STATE(259), - [sym_object_literal] = STATE(259), - [sym_lambda_expression] = STATE(259), - [sym_literal] = STATE(259), + [sym_expression] = STATE(238), + [sym_match_expression] = STATE(280), + [sym_if_expression] = STATE(280), + [sym_handler_expression] = STATE(280), + [sym_kernel_expression] = STATE(280), + [sym_select_expression] = STATE(280), + [sym_ternary_expression] = STATE(280), + [sym_binary_expression] = STATE(280), + [sym_unary_expression] = STATE(280), + [sym_pipe_expression] = STATE(280), + [sym_call_expression] = STATE(280), + [sym_primary_expression] = STATE(280), + [sym_spawn_expression] = STATE(293), + [sym_yield_expression] = STATE(293), + [sym_await_call] = STATE(293), + [sym_send_call] = STATE(293), + [sym_recv_call] = STATE(293), + [sym_perform_expression] = STATE(293), + [sym_resume_expression] = STATE(293), + [sym_type_constructor] = STATE(293), + [sym_update_expression] = STATE(293), + [sym_block] = STATE(293), + [sym_object_literal] = STATE(293), + [sym_lambda_expression] = STATE(293), + [sym_literal] = STATE(293), [sym_list_literal] = STATE(273), [sym_map_literal] = STATE(273), - [sym_qualified_path] = STATE(250), + [sym_qualified_path] = STATE(235), [sym_boolean] = STATE(273), [sym_identifier] = ACTIONS(252), [anon_sym_DOT] = ACTIONS(83), @@ -8950,6 +9016,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_match] = ACTIONS(266), [anon_sym_if] = ACTIONS(268), [anon_sym_handle] = ACTIONS(270), + [anon_sym_do] = ACTIONS(87), [anon_sym_kernel] = ACTIONS(272), [anon_sym_select] = ACTIONS(274), [anon_sym_QMARK] = ACTIONS(83), @@ -8983,35 +9050,35 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__call_open_gap] = ACTIONS(83), }, [19] = { - [sym_expression] = STATE(447), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_expression] = STATE(444), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_identifier] = ACTIONS(300), [anon_sym_DOT] = ACTIONS(83), [anon_sym_LBRACE] = ACTIONS(11), @@ -9062,35 +9129,35 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__statement_break] = ACTIONS(83), }, [20] = { - [sym_expression] = STATE(610), - [sym_match_expression] = STATE(473), - [sym_if_expression] = STATE(473), - [sym_handler_expression] = STATE(473), - [sym_kernel_expression] = STATE(473), - [sym_select_expression] = STATE(473), - [sym_ternary_expression] = STATE(473), - [sym_binary_expression] = STATE(473), - [sym_unary_expression] = STATE(473), - [sym_pipe_expression] = STATE(473), - [sym_call_expression] = STATE(473), - [sym_primary_expression] = STATE(473), - [sym_spawn_expression] = STATE(493), - [sym_yield_expression] = STATE(493), - [sym_await_call] = STATE(493), - [sym_send_call] = STATE(493), - [sym_recv_call] = STATE(493), - [sym_perform_expression] = STATE(493), - [sym_resume_expression] = STATE(493), - [sym_type_constructor] = STATE(493), - [sym_update_expression] = STATE(493), - [sym_block] = STATE(493), - [sym_object_literal] = STATE(493), - [sym_lambda_expression] = STATE(493), - [sym_literal] = STATE(493), - [sym_list_literal] = STATE(477), - [sym_map_literal] = STATE(477), - [sym_qualified_path] = STATE(460), - [sym_boolean] = STATE(477), + [sym_expression] = STATE(535), + [sym_match_expression] = STATE(502), + [sym_if_expression] = STATE(502), + [sym_handler_expression] = STATE(502), + [sym_kernel_expression] = STATE(502), + [sym_select_expression] = STATE(502), + [sym_ternary_expression] = STATE(502), + [sym_binary_expression] = STATE(502), + [sym_unary_expression] = STATE(502), + [sym_pipe_expression] = STATE(502), + [sym_call_expression] = STATE(502), + [sym_primary_expression] = STATE(502), + [sym_spawn_expression] = STATE(525), + [sym_yield_expression] = STATE(525), + [sym_await_call] = STATE(525), + [sym_send_call] = STATE(525), + [sym_recv_call] = STATE(525), + [sym_perform_expression] = STATE(525), + [sym_resume_expression] = STATE(525), + [sym_type_constructor] = STATE(525), + [sym_update_expression] = STATE(525), + [sym_block] = STATE(525), + [sym_object_literal] = STATE(525), + [sym_lambda_expression] = STATE(525), + [sym_literal] = STATE(525), + [sym_list_literal] = STATE(510), + [sym_map_literal] = STATE(510), + [sym_qualified_path] = STATE(450), + [sym_boolean] = STATE(510), [sym_identifier] = ACTIONS(300), [anon_sym_LBRACE] = ACTIONS(11), [anon_sym_namespace] = ACTIONS(310), @@ -9176,16 +9243,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1460), 1, + STATE(1526), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9201,7 +9268,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9213,7 +9280,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9270,15 +9337,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(338), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1443), 1, + STATE(1391), 1, sym_argument_list, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9295,7 +9362,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9307,7 +9374,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9364,15 +9431,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(340), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, - STATE(1493), 1, + STATE(1728), 1, sym_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9389,7 +9456,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9401,7 +9468,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9458,16 +9525,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(342), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1679), 1, + STATE(1435), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9483,7 +9550,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9495,7 +9562,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9552,15 +9619,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(344), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1425), 1, + STATE(1392), 1, sym_argument_list, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9577,7 +9644,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9589,7 +9656,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9646,15 +9713,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(346), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1382), 1, + STATE(1455), 1, sym_argument_list, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9671,7 +9738,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9683,7 +9750,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9740,16 +9807,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(348), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1516), 1, + STATE(1382), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9765,7 +9832,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9777,7 +9844,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9834,16 +9901,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(350), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1517), 1, + STATE(1537), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9859,7 +9926,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9871,7 +9938,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9928,16 +9995,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(352), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1527), 1, + STATE(1567), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -9953,7 +10020,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9965,7 +10032,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10022,16 +10089,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(354), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1449), 1, - sym_named_argument_list, - STATE(1531), 1, + STATE(1527), 1, sym_argument_list, + STATE(1568), 1, + sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10047,7 +10114,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10059,7 +10126,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10116,15 +10183,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(356), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1445), 1, + STATE(1541), 1, sym_argument_list, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -10141,7 +10208,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10153,7 +10220,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10210,16 +10277,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(358), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(444), 1, + STATE(441), 1, sym_expression, - STATE(1240), 1, + STATE(1214), 1, sym_named_argument, - STATE(1381), 1, - sym_argument_list, - STATE(1449), 1, + STATE(1568), 1, sym_named_argument_list, + STATE(1627), 1, + sym_argument_list, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10235,7 +10302,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10247,7 +10314,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10304,9 +10371,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(360), 1, anon_sym_RPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(575), 1, + STATE(573), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10323,7 +10390,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10335,7 +10402,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10391,10 +10458,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(336), 1, anon_sym_LBRACK, ACTIONS(362), 1, - anon_sym_RBRACK, - STATE(250), 1, + anon_sym_RPAREN, + STATE(235), 1, sym_qualified_path, - STATE(457), 1, + STATE(548), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10411,7 +10478,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10423,7 +10490,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10438,6 +10505,8 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [1746] = 29, + ACTIONS(252), 1, + sym_identifier, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -10476,14 +10545,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(364), 1, - sym_identifier, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(606), 1, + STATE(541), 1, sym_expression, - STATE(1360), 1, - sym_field_pattern, + STATE(1347), 1, + sym_map_entry, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10499,7 +10566,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10511,7 +10578,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10566,11 +10633,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - anon_sym_COLON, - STATE(250), 1, + ACTIONS(364), 1, + anon_sym_RBRACK, + STATE(235), 1, sym_qualified_path, - STATE(577), 1, + STATE(469), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10587,7 +10654,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10599,7 +10666,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10654,11 +10721,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(368), 1, - anon_sym_RPAREN, - STATE(250), 1, + ACTIONS(366), 1, + anon_sym_COLON, + STATE(235), 1, sym_qualified_path, - STATE(556), 1, + STATE(550), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10675,7 +10742,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10687,7 +10754,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10742,12 +10809,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + ACTIONS(368), 1, + anon_sym_RBRACK, + STATE(235), 1, sym_qualified_path, - STATE(571), 1, + STATE(463), 1, sym_expression, - STATE(1278), 1, - sym_map_entry, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -10763,7 +10830,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10775,7 +10842,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10832,9 +10899,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(370), 1, anon_sym_COLON, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(589), 1, + STATE(539), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10851,7 +10918,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10863,7 +10930,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10919,10 +10986,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(336), 1, anon_sym_LBRACK, ACTIONS(372), 1, - anon_sym_RBRACK, - STATE(250), 1, + anon_sym_RPAREN, + STATE(235), 1, sym_qualified_path, - STATE(467), 1, + STATE(578), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10939,7 +11006,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10951,7 +11018,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10966,6 +11033,8 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [2448] = 29, + ACTIONS(252), 1, + sym_identifier, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -11004,14 +11073,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(364), 1, - sym_identifier, - STATE(250), 1, + ACTIONS(374), 1, + anon_sym_COLON, + STATE(235), 1, sym_qualified_path, - STATE(542), 1, + STATE(580), 1, sym_expression, - STATE(1360), 1, - sym_field_pattern, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -11027,7 +11094,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11039,7 +11106,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11054,8 +11121,6 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [2565] = 29, - ACTIONS(252), 1, - sym_identifier, ACTIONS(254), 1, anon_sym_LBRACE, ACTIONS(256), 1, @@ -11094,12 +11159,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(374), 1, - anon_sym_RPAREN, - STATE(250), 1, + ACTIONS(376), 1, + sym_identifier, + STATE(235), 1, sym_qualified_path, - STATE(546), 1, + STATE(562), 1, sym_expression, + STATE(1736), 1, + sym_field_pattern, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -11115,7 +11182,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11127,7 +11194,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11182,11 +11249,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(376), 1, + ACTIONS(378), 1, anon_sym_RBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(464), 1, + STATE(457), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11203,7 +11270,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11215,7 +11282,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11268,13 +11335,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(364), 1, + ACTIONS(376), 1, sym_identifier, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, STATE(603), 1, sym_expression, - STATE(1360), 1, + STATE(1736), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -11291,7 +11358,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11303,7 +11370,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11318,6 +11385,94 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [2916] = 29, + ACTIONS(254), 1, + anon_sym_LBRACE, + ACTIONS(256), 1, + anon_sym_fn, + ACTIONS(258), 1, + anon_sym_LPAREN, + ACTIONS(266), 1, + anon_sym_match, + ACTIONS(268), 1, + anon_sym_if, + ACTIONS(270), 1, + anon_sym_handle, + ACTIONS(272), 1, + anon_sym_kernel, + ACTIONS(274), 1, + anon_sym_select, + ACTIONS(278), 1, + anon_sym_await, + ACTIONS(280), 1, + anon_sym_spawn, + ACTIONS(282), 1, + anon_sym_yield, + ACTIONS(284), 1, + anon_sym_send, + ACTIONS(286), 1, + anon_sym_recv, + ACTIONS(288), 1, + anon_sym_perform, + ACTIONS(290), 1, + anon_sym_resume, + ACTIONS(294), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(334), 1, + anon_sym_PIPE, + ACTIONS(336), 1, + anon_sym_LBRACK, + ACTIONS(376), 1, + sym_identifier, + STATE(235), 1, + sym_qualified_path, + STATE(605), 1, + sym_expression, + STATE(1736), 1, + sym_field_pattern, + ACTIONS(292), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(276), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(296), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(273), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(280), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(293), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [3033] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -11358,97 +11513,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - ACTIONS(378), 1, - anon_sym_COLON, - STATE(250), 1, - sym_qualified_path, - STATE(548), 1, - sym_expression, - ACTIONS(292), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(276), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(296), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(273), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(258), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(259), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3033] = 28, - ACTIONS(252), 1, - sym_identifier, - ACTIONS(254), 1, - anon_sym_LBRACE, - ACTIONS(256), 1, - anon_sym_fn, - ACTIONS(258), 1, - anon_sym_LPAREN, - ACTIONS(266), 1, - anon_sym_match, - ACTIONS(268), 1, - anon_sym_if, - ACTIONS(270), 1, - anon_sym_handle, - ACTIONS(272), 1, - anon_sym_kernel, - ACTIONS(274), 1, - anon_sym_select, - ACTIONS(278), 1, - anon_sym_await, - ACTIONS(280), 1, - anon_sym_spawn, - ACTIONS(282), 1, - anon_sym_yield, - ACTIONS(284), 1, - anon_sym_send, - ACTIONS(286), 1, - anon_sym_recv, - ACTIONS(288), 1, - anon_sym_perform, - ACTIONS(290), 1, - anon_sym_resume, - ACTIONS(294), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(334), 1, - anon_sym_PIPE, - ACTIONS(336), 1, - anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(560), 1, + STATE(587), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11465,7 +11532,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11477,7 +11544,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11532,9 +11599,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(562), 1, + STATE(554), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11551,7 +11618,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11563,7 +11630,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11618,10 +11685,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(455), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(456), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -11633,11 +11700,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11649,7 +11716,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11704,9 +11771,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(528), 1, + STATE(531), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -11719,11 +11786,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11735,7 +11802,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11790,9 +11857,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(554), 1, + STATE(538), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -11805,11 +11872,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11821,7 +11888,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11878,7 +11945,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(443), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -11891,11 +11958,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11907,7 +11974,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11962,9 +12029,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(530), 1, + STATE(568), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11981,7 +12048,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11993,7 +12060,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12048,9 +12115,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(588), 1, + STATE(561), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12063,11 +12130,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12079,7 +12146,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12134,7 +12201,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, STATE(394), 1, sym_expression, @@ -12153,7 +12220,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12165,7 +12232,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12220,9 +12287,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(446), 1, + STATE(449), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -12235,11 +12302,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12251,7 +12318,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12306,9 +12373,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(498), 1, + STATE(453), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12325,7 +12392,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12337,7 +12404,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12393,9 +12460,9 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(302), 1, anon_sym_fn, STATE(450), 1, - sym_expression, - STATE(460), 1, sym_qualified_path, + STATE(455), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12407,11 +12474,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12423,7 +12490,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12478,9 +12545,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(502), 1, + STATE(498), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12497,7 +12564,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12509,7 +12576,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12564,9 +12631,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(441), 1, + STATE(448), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -12579,11 +12646,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12595,7 +12662,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12650,9 +12717,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(518), 1, + STATE(480), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12669,7 +12736,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12681,7 +12748,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12736,9 +12803,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(576), 1, + STATE(549), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12755,7 +12822,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12767,7 +12834,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12822,10 +12889,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(451), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(461), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -12837,11 +12904,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12853,7 +12920,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12908,9 +12975,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(534), 1, + STATE(569), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12923,11 +12990,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12939,7 +13006,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12994,9 +13061,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(541), 1, + STATE(570), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13009,11 +13076,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13025,7 +13092,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13080,10 +13147,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(458), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(464), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -13095,11 +13162,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13111,7 +13178,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13166,9 +13233,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(550), 1, + STATE(595), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13181,11 +13248,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13197,7 +13264,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13252,9 +13319,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(536), 1, + STATE(592), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13267,11 +13334,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13283,7 +13350,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13338,9 +13405,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(537), 1, + STATE(527), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13353,11 +13420,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13369,7 +13436,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13424,10 +13491,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(445), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(468), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -13439,11 +13506,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13455,7 +13522,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13510,9 +13577,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(552), 1, + STATE(596), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13525,11 +13592,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13541,7 +13608,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13596,9 +13663,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(564), 1, + STATE(597), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13611,11 +13678,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13627,7 +13694,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13682,9 +13749,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(566), 1, + STATE(599), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -13701,7 +13768,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13713,7 +13780,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13768,9 +13835,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(462), 1, + STATE(470), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13783,11 +13850,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13799,7 +13866,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13854,9 +13921,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(569), 1, + STATE(606), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13869,11 +13936,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13885,7 +13952,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13940,9 +14007,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(570), 1, + STATE(607), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13955,11 +14022,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13971,7 +14038,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14026,9 +14093,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(579), 1, + STATE(608), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14041,11 +14108,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14057,7 +14124,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14112,9 +14179,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(586), 1, + STATE(593), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14127,11 +14194,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14143,7 +14210,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14198,9 +14265,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(587), 1, + STATE(565), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14213,11 +14280,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14229,7 +14296,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14284,11 +14351,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(590), 1, + STATE(534), 1, sym_call_expression, - STATE(614), 1, + STATE(622), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -14305,7 +14372,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 10, + STATE(280), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14316,7 +14383,7 @@ static const uint16_t ts_small_parse_table[] = { sym_unary_expression, sym_pipe_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14371,9 +14438,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(592), 1, + STATE(533), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14386,11 +14453,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14402,7 +14469,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14457,9 +14524,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(595), 1, + STATE(542), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14472,11 +14539,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14488,7 +14555,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14543,9 +14610,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(597), 1, + STATE(588), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14558,11 +14625,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14574,7 +14641,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14629,9 +14696,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(598), 1, + STATE(589), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14644,11 +14711,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14660,7 +14727,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14715,9 +14782,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(600), 1, + STATE(530), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14730,11 +14797,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14746,7 +14813,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14801,9 +14868,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(601), 1, + STATE(532), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14816,11 +14883,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14832,7 +14899,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14887,9 +14954,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(607), 1, + STATE(536), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14902,11 +14969,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14918,7 +14985,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14973,9 +15040,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(608), 1, + STATE(537), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14988,11 +15055,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15004,7 +15071,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15059,9 +15126,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(609), 1, + STATE(540), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15074,11 +15141,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15090,7 +15157,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15145,9 +15212,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(527), 1, + STATE(544), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15160,11 +15227,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15176,7 +15243,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15231,9 +15298,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(567), 1, + STATE(557), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15246,11 +15313,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15262,7 +15329,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15317,9 +15384,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(532), 1, + STATE(560), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15332,11 +15399,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15348,7 +15415,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15403,9 +15470,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(535), 1, + STATE(572), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15418,11 +15485,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15434,7 +15501,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15489,9 +15556,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(555), 1, + STATE(574), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15504,11 +15571,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15520,7 +15587,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15575,9 +15642,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(559), 1, + STATE(579), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15590,11 +15657,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15606,7 +15673,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15661,9 +15728,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(596), 1, + STATE(585), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15676,11 +15743,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15692,7 +15759,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15747,9 +15814,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(529), 1, + STATE(590), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15762,11 +15829,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15778,7 +15845,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15833,9 +15900,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(531), 1, + STATE(591), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15848,11 +15915,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15864,7 +15931,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15919,9 +15986,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(557), 1, + STATE(600), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15934,11 +16001,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15950,7 +16017,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16005,9 +16072,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(565), 1, + STATE(601), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16020,11 +16087,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16036,7 +16103,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16091,9 +16158,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(591), 1, + STATE(529), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16106,11 +16173,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16122,7 +16189,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16177,10 +16244,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(236), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(240), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16196,7 +16263,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16208,7 +16275,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16264,9 +16331,9 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(336), 1, anon_sym_LBRACK, STATE(235), 1, - sym_expression, - STATE(250), 1, sym_qualified_path, + STATE(241), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16282,7 +16349,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16294,7 +16361,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16349,10 +16416,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(239), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(242), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16368,7 +16435,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16380,7 +16447,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16435,10 +16502,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(240), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(243), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16454,7 +16521,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16466,7 +16533,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16521,10 +16588,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(243), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(244), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16540,7 +16607,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16552,7 +16619,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16607,10 +16674,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(244), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(245), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16626,7 +16693,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16638,7 +16705,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16693,9 +16760,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(465), 1, + STATE(471), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16708,11 +16775,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16724,7 +16791,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16779,9 +16846,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(301), 1, + STATE(320), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -16794,11 +16861,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16810,7 +16877,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16865,10 +16932,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, + STATE(235), 1, + sym_qualified_path, STATE(246), 1, sym_expression, - STATE(250), 1, - sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16884,7 +16951,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16896,7 +16963,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16951,10 +17018,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(248), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(247), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -16970,7 +17037,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16982,7 +17049,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17037,10 +17104,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(249), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(248), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17056,7 +17123,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17068,7 +17135,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17123,9 +17190,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(252), 1, + STATE(249), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -17142,7 +17209,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17154,7 +17221,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17209,10 +17276,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(233), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(250), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17228,7 +17295,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17240,7 +17307,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17295,10 +17362,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(234), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(251), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17314,7 +17381,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17326,7 +17393,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17381,10 +17448,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, - sym_qualified_path, - STATE(345), 1, + STATE(302), 1, sym_expression, + STATE(330), 1, + sym_qualified_path, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -17396,11 +17463,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17412,7 +17479,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17467,10 +17534,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, - sym_qualified_path, - STATE(353), 1, + STATE(308), 1, sym_expression, + STATE(330), 1, + sym_qualified_path, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -17482,11 +17549,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17498,7 +17565,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17553,10 +17620,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(237), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(252), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17572,7 +17639,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17584,7 +17651,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17639,9 +17706,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(355), 1, + STATE(331), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -17654,11 +17721,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17670,7 +17737,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17685,6 +17752,92 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [11357] = 28, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(33), 1, + anon_sym_LBRACK, + ACTIONS(35), 1, + anon_sym_match, + ACTIONS(37), 1, + anon_sym_if, + ACTIONS(39), 1, + anon_sym_handle, + ACTIONS(41), 1, + anon_sym_kernel, + ACTIONS(43), 1, + anon_sym_select, + ACTIONS(45), 1, + anon_sym_await, + ACTIONS(47), 1, + anon_sym_spawn, + ACTIONS(49), 1, + anon_sym_yield, + ACTIONS(51), 1, + anon_sym_send, + ACTIONS(53), 1, + anon_sym_recv, + ACTIONS(55), 1, + anon_sym_perform, + ACTIONS(57), 1, + anon_sym_resume, + ACTIONS(67), 1, + sym_float, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(300), 1, + sym_identifier, + ACTIONS(302), 1, + anon_sym_fn, + STATE(450), 1, + sym_qualified_path, + STATE(472), 1, + sym_expression, + ACTIONS(65), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(31), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(69), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(510), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(502), 11, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_kernel_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(525), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [11471] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17725,10 +17878,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(241), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(253), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17744,7 +17897,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17756,7 +17909,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17770,7 +17923,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11471] = 28, + [11585] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17811,9 +17964,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(242), 1, + STATE(233), 1, sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, ACTIONS(292), 2, anon_sym_true, @@ -17830,7 +17983,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17842,7 +17995,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17856,7 +18009,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11585] = 28, + [11699] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -17897,10 +18050,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(247), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(254), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -17916,7 +18069,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17928,7 +18081,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17942,7 +18095,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11699] = 28, + [11813] = 28, ACTIONS(81), 1, sym_identifier, ACTIONS(85), 1, @@ -17983,9 +18136,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(307), 1, + STATE(298), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -17998,11 +18151,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18014,7 +18167,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18028,7 +18181,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11813] = 28, + [11927] = 28, ACTIONS(81), 1, sym_identifier, ACTIONS(85), 1, @@ -18069,10 +18222,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, - sym_qualified_path, - STATE(330), 1, + STATE(301), 1, sym_expression, + STATE(330), 1, + sym_qualified_path, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -18084,11 +18237,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18100,7 +18253,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18114,7 +18267,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11927] = 28, + [12041] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -18155,9 +18308,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(253), 1, + STATE(255), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -18174,7 +18327,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18186,7 +18339,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18200,7 +18353,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12041] = 28, + [12155] = 28, ACTIONS(252), 1, sym_identifier, ACTIONS(254), 1, @@ -18241,9 +18394,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(612), 1, + STATE(626), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -18260,7 +18413,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18272,7 +18425,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18286,7 +18439,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12155] = 28, + [12269] = 28, ACTIONS(81), 1, sym_identifier, ACTIONS(85), 1, @@ -18327,10 +18480,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(325), 1, - sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, + STATE(354), 1, + sym_expression, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -18342,11 +18495,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18358,7 +18511,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18372,7 +18525,7 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12269] = 28, + [12383] = 28, ACTIONS(81), 1, sym_identifier, ACTIONS(85), 1, @@ -18413,10 +18566,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(298), 1, - sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, + STATE(337), 1, + sym_expression, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -18428,11 +18581,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18444,93 +18597,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [12383] = 28, - ACTIONS(11), 1, - anon_sym_LBRACE, - ACTIONS(19), 1, - anon_sym_LPAREN, - ACTIONS(25), 1, - anon_sym_PIPE, - ACTIONS(33), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_match, - ACTIONS(37), 1, - anon_sym_if, - ACTIONS(39), 1, - anon_sym_handle, - ACTIONS(41), 1, - anon_sym_kernel, - ACTIONS(43), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_await, - ACTIONS(47), 1, - anon_sym_spawn, - ACTIONS(49), 1, - anon_sym_yield, - ACTIONS(51), 1, - anon_sym_send, - ACTIONS(53), 1, - anon_sym_recv, - ACTIONS(55), 1, - anon_sym_perform, - ACTIONS(57), 1, - anon_sym_resume, - ACTIONS(67), 1, - sym_float, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(300), 1, - sym_identifier, - ACTIONS(302), 1, - anon_sym_fn, - STATE(460), 1, - sym_qualified_path, - STATE(466), 1, - sym_expression, - ACTIONS(65), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(31), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(69), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(477), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(473), 11, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_kernel_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(493), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18585,9 +18652,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(251), 1, + STATE(256), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -18604,7 +18671,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18616,7 +18683,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18673,7 +18740,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(299), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -18686,11 +18753,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18702,7 +18769,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18759,7 +18826,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(300), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -18772,11 +18839,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18788,7 +18855,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18843,10 +18910,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, - sym_qualified_path, - STATE(256), 1, + STATE(234), 1, sym_expression, + STATE(235), 1, + sym_qualified_path, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -18862,7 +18929,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18874,7 +18941,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18929,9 +18996,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(302), 1, + STATE(303), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -18944,11 +19011,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18960,7 +19027,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19015,9 +19082,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(303), 1, + STATE(304), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19030,11 +19097,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19046,7 +19113,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19061,66 +19128,66 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [13181] = 28, - ACTIONS(252), 1, + ACTIONS(81), 1, sym_identifier, - ACTIONS(254), 1, + ACTIONS(85), 1, anon_sym_LBRACE, - ACTIONS(256), 1, + ACTIONS(89), 1, anon_sym_fn, - ACTIONS(258), 1, + ACTIONS(91), 1, anon_sym_LPAREN, - ACTIONS(266), 1, + ACTIONS(99), 1, anon_sym_match, - ACTIONS(268), 1, + ACTIONS(101), 1, anon_sym_if, - ACTIONS(270), 1, + ACTIONS(103), 1, anon_sym_handle, - ACTIONS(272), 1, + ACTIONS(105), 1, anon_sym_kernel, - ACTIONS(274), 1, + ACTIONS(107), 1, anon_sym_select, - ACTIONS(278), 1, + ACTIONS(111), 1, anon_sym_await, - ACTIONS(280), 1, + ACTIONS(113), 1, anon_sym_spawn, - ACTIONS(282), 1, + ACTIONS(115), 1, anon_sym_yield, - ACTIONS(284), 1, + ACTIONS(117), 1, anon_sym_send, - ACTIONS(286), 1, + ACTIONS(119), 1, anon_sym_recv, - ACTIONS(288), 1, + ACTIONS(121), 1, anon_sym_perform, - ACTIONS(290), 1, + ACTIONS(123), 1, anon_sym_resume, - ACTIONS(294), 1, + ACTIONS(127), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(334), 1, + ACTIONS(380), 1, anon_sym_PIPE, - ACTIONS(336), 1, + ACTIONS(382), 1, anon_sym_LBRACK, - STATE(250), 1, - sym_qualified_path, - STATE(561), 1, + STATE(305), 1, sym_expression, - ACTIONS(292), 2, + STATE(330), 1, + sym_qualified_path, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(276), 3, + ACTIONS(109), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(296), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(273), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19132,7 +19199,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19187,9 +19254,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(305), 1, + STATE(306), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19202,11 +19269,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19218,7 +19285,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19273,9 +19340,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(306), 1, + STATE(307), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19288,11 +19355,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19304,7 +19371,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19359,9 +19426,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(308), 1, + STATE(309), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19374,11 +19441,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19390,7 +19457,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19445,9 +19512,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(309), 1, + STATE(310), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19460,11 +19527,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19476,7 +19543,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19531,9 +19598,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(310), 1, + STATE(311), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19546,11 +19613,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19562,7 +19629,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19617,9 +19684,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(311), 1, + STATE(312), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19632,11 +19699,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19648,7 +19715,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19663,66 +19730,66 @@ static const uint16_t ts_small_parse_table[] = { sym_lambda_expression, sym_literal, [13979] = 28, - ACTIONS(81), 1, + ACTIONS(252), 1, sym_identifier, - ACTIONS(85), 1, + ACTIONS(254), 1, anon_sym_LBRACE, - ACTIONS(89), 1, + ACTIONS(256), 1, anon_sym_fn, - ACTIONS(91), 1, + ACTIONS(258), 1, anon_sym_LPAREN, - ACTIONS(99), 1, + ACTIONS(266), 1, anon_sym_match, - ACTIONS(101), 1, + ACTIONS(268), 1, anon_sym_if, - ACTIONS(103), 1, + ACTIONS(270), 1, anon_sym_handle, - ACTIONS(105), 1, + ACTIONS(272), 1, anon_sym_kernel, - ACTIONS(107), 1, + ACTIONS(274), 1, anon_sym_select, - ACTIONS(111), 1, + ACTIONS(278), 1, anon_sym_await, - ACTIONS(113), 1, + ACTIONS(280), 1, anon_sym_spawn, - ACTIONS(115), 1, + ACTIONS(282), 1, anon_sym_yield, - ACTIONS(117), 1, + ACTIONS(284), 1, anon_sym_send, - ACTIONS(119), 1, + ACTIONS(286), 1, anon_sym_recv, - ACTIONS(121), 1, + ACTIONS(288), 1, anon_sym_perform, - ACTIONS(123), 1, + ACTIONS(290), 1, anon_sym_resume, - ACTIONS(127), 1, + ACTIONS(294), 1, sym_float, ACTIONS(298), 1, sym_line_comment, - ACTIONS(380), 1, + ACTIONS(334), 1, anon_sym_PIPE, - ACTIONS(382), 1, + ACTIONS(336), 1, anon_sym_LBRACK, - STATE(312), 1, - sym_expression, - STATE(329), 1, + STATE(235), 1, sym_qualified_path, - ACTIONS(125), 2, + STATE(564), 1, + sym_expression, + ACTIONS(292), 2, anon_sym_true, anon_sym_false, - ACTIONS(109), 3, + ACTIONS(276), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(129), 3, + ACTIONS(296), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(273), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19734,7 +19801,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19789,9 +19856,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(313), 1, + STATE(314), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19804,11 +19871,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19820,7 +19887,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19875,9 +19942,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(314), 1, + STATE(315), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19890,11 +19957,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19906,7 +19973,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19961,9 +20028,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(315), 1, + STATE(316), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -19976,11 +20043,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19992,7 +20059,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20047,9 +20114,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(316), 1, + STATE(317), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20062,11 +20129,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20078,7 +20145,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20133,9 +20200,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(317), 1, + STATE(318), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20148,11 +20215,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20164,7 +20231,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20219,9 +20286,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(318), 1, + STATE(319), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20234,11 +20301,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20250,7 +20317,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20305,9 +20372,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(319), 1, + STATE(297), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20320,11 +20387,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20336,7 +20403,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20391,9 +20458,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(320), 1, + STATE(321), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20406,11 +20473,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20422,7 +20489,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20477,9 +20544,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(321), 1, + STATE(322), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20492,11 +20559,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20508,7 +20575,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20563,9 +20630,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(322), 1, + STATE(323), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20578,11 +20645,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20594,7 +20661,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20649,9 +20716,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(323), 1, + STATE(324), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20664,11 +20731,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20680,7 +20747,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20735,9 +20802,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(324), 1, + STATE(325), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20750,11 +20817,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20766,7 +20833,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20821,10 +20888,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, - sym_qualified_path, - STATE(356), 1, + STATE(326), 1, sym_expression, + STATE(330), 1, + sym_qualified_path, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -20836,11 +20903,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20852,7 +20919,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20907,9 +20974,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(326), 1, + STATE(327), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -20922,11 +20989,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20938,7 +21005,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20993,9 +21060,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(327), 1, + STATE(328), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -21008,11 +21075,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21024,7 +21091,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21079,9 +21146,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(328), 1, - sym_expression, STATE(329), 1, + sym_expression, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -21094,11 +21161,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21110,7 +21177,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21165,9 +21232,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(453), 1, + STATE(442), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -21180,11 +21247,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21196,7 +21263,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21251,9 +21318,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(334), 1, + STATE(335), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21266,11 +21333,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21282,7 +21349,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21337,9 +21404,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(335), 1, + STATE(336), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21352,11 +21419,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21368,7 +21435,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21423,9 +21490,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(336), 1, + STATE(356), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21438,11 +21505,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21454,7 +21521,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21509,9 +21576,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(337), 1, + STATE(338), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21524,11 +21591,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21540,7 +21607,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21595,9 +21662,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(338), 1, + STATE(339), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21610,11 +21677,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21626,7 +21693,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21681,9 +21748,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(339), 1, + STATE(340), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21696,11 +21763,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21712,7 +21779,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21767,9 +21834,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(340), 1, + STATE(341), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21782,11 +21849,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21798,7 +21865,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21853,9 +21920,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(341), 1, + STATE(342), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21868,11 +21935,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21884,7 +21951,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21939,9 +22006,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(342), 1, + STATE(343), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -21954,11 +22021,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21970,7 +22037,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22025,9 +22092,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(343), 1, + STATE(344), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22040,11 +22107,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22056,7 +22123,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22111,9 +22178,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(344), 1, + STATE(345), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22126,11 +22193,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22142,7 +22209,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22197,10 +22264,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(297), 1, - sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, + STATE(346), 1, + sym_expression, ACTIONS(125), 2, anon_sym_true, anon_sym_false, @@ -22212,11 +22279,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22228,7 +22295,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22283,9 +22350,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(346), 1, + STATE(347), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22298,11 +22365,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22314,7 +22381,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22369,9 +22436,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(347), 1, + STATE(348), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22384,11 +22451,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22400,7 +22467,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22455,9 +22522,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(348), 1, + STATE(349), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22470,11 +22537,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22486,7 +22553,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22541,9 +22608,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(349), 1, + STATE(350), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22556,11 +22623,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22572,7 +22639,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22627,9 +22694,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(350), 1, + STATE(351), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22642,11 +22709,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22658,7 +22725,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22713,9 +22780,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(351), 1, + STATE(352), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22728,11 +22795,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22744,7 +22811,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22799,9 +22866,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(352), 1, + STATE(353), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -22814,11 +22881,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22830,7 +22897,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22885,9 +22952,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(468), 1, + STATE(458), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -22900,11 +22967,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22916,7 +22983,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22971,9 +23038,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(254), 1, + STATE(236), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -22990,7 +23057,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23002,7 +23069,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23057,9 +23124,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(469), 1, + STATE(459), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -23072,11 +23139,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23088,7 +23155,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23143,9 +23210,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(384), 1, anon_sym_LPAREN, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(254), 1, + STATE(236), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23162,7 +23229,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23174,7 +23241,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23229,10 +23296,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(238), 1, - sym_expression, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, + STATE(237), 1, + sym_expression, ACTIONS(292), 2, anon_sym_true, anon_sym_false, @@ -23248,7 +23315,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23260,7 +23327,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23315,9 +23382,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(470), 1, + STATE(465), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -23330,11 +23397,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23346,7 +23413,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23401,9 +23468,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(471), 1, + STATE(466), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -23416,11 +23483,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23432,7 +23499,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23487,9 +23554,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(599), 1, + STATE(609), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23506,7 +23573,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23518,7 +23585,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23573,9 +23640,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(620), 1, + STATE(625), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23592,7 +23659,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23604,7 +23671,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23659,9 +23726,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(472), 1, + STATE(477), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23678,7 +23745,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23690,7 +23757,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23745,7 +23812,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, STATE(496), 1, sym_expression, @@ -23764,7 +23831,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23776,7 +23843,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23831,9 +23898,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(624), 1, + STATE(613), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23850,7 +23917,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23862,7 +23929,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23917,9 +23984,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(331), 1, + STATE(332), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -23932,11 +23999,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23948,7 +24015,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24003,9 +24070,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(593), 1, + STATE(582), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -24018,11 +24085,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24034,7 +24101,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24089,9 +24156,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(386), 1, anon_sym_LPAREN, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(331), 1, + STATE(332), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -24104,11 +24171,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24120,7 +24187,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24175,9 +24242,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, - STATE(332), 1, + STATE(333), 1, sym_expression, ACTIONS(125), 2, anon_sym_true, @@ -24190,11 +24257,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24206,7 +24273,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24261,9 +24328,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, - STATE(461), 1, + STATE(452), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -24276,11 +24343,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24292,7 +24359,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24347,9 +24414,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(448), 1, + STATE(473), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24366,7 +24433,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24378,7 +24445,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24433,9 +24500,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, ACTIONS(388), 1, anon_sym_LPAREN, - STATE(453), 1, + STATE(442), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -24448,11 +24515,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24464,7 +24531,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24519,10 +24586,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(456), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(451), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -24534,11 +24601,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24550,7 +24617,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24605,9 +24672,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(454), 1, + STATE(446), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -24620,11 +24687,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24636,7 +24703,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24691,9 +24758,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(583), 1, + STATE(555), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24710,7 +24777,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24722,7 +24789,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24777,9 +24844,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(558), 1, + STATE(567), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24796,7 +24863,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24808,7 +24875,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24863,10 +24930,10 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(449), 1, - sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, + STATE(460), 1, + sym_expression, ACTIONS(65), 2, anon_sym_true, anon_sym_false, @@ -24878,11 +24945,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24894,7 +24961,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24949,9 +25016,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(539), 1, + STATE(543), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24968,7 +25035,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24980,7 +25047,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25035,9 +25102,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(544), 1, + STATE(546), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25054,7 +25121,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25066,7 +25133,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25121,9 +25188,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(545), 1, + STATE(547), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25140,7 +25207,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25152,7 +25219,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25207,9 +25274,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(549), 1, + STATE(551), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25226,7 +25293,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25238,7 +25305,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25293,9 +25360,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(553), 1, + STATE(556), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25312,7 +25379,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25324,7 +25391,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25379,9 +25446,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(506), 1, + STATE(563), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25398,7 +25465,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25410,7 +25477,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25465,9 +25532,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(563), 1, + STATE(566), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25484,7 +25551,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25496,7 +25563,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25551,9 +25618,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(568), 1, + STATE(571), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25570,7 +25637,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25582,7 +25649,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25637,9 +25704,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(573), 1, + STATE(576), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25656,7 +25723,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25668,7 +25735,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25723,9 +25790,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(574), 1, + STATE(577), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25742,7 +25809,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25754,7 +25821,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25809,9 +25876,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(578), 1, + STATE(581), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25828,7 +25895,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25840,7 +25907,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25895,9 +25962,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(581), 1, + STATE(584), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25914,7 +25981,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25926,7 +25993,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25981,9 +26048,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(584), 1, + STATE(586), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26000,7 +26067,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26012,7 +26079,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26067,9 +26134,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(585), 1, + STATE(454), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26086,7 +26153,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26098,7 +26165,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26153,9 +26220,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(615), 1, + STATE(616), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26172,7 +26239,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26184,7 +26251,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26239,9 +26306,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(618), 1, + STATE(619), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26258,7 +26325,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26270,7 +26337,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26325,7 +26392,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, STATE(602), 1, sym_expression, @@ -26344,7 +26411,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26356,7 +26423,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26411,9 +26478,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(302), 1, anon_sym_fn, - STATE(459), 1, + STATE(447), 1, sym_expression, - STATE(460), 1, + STATE(450), 1, sym_qualified_path, ACTIONS(65), 2, anon_sym_true, @@ -26426,11 +26493,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(477), 3, + STATE(510), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(473), 11, + STATE(502), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26442,7 +26509,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(493), 13, + STATE(525), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26497,9 +26564,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(512), 1, + STATE(604), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26516,7 +26583,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26528,7 +26595,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26583,9 +26650,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(605), 1, + STATE(492), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26602,7 +26669,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26614,7 +26681,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26669,7 +26736,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, STATE(395), 1, sym_expression, @@ -26688,7 +26755,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26700,7 +26767,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26755,9 +26822,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(336), 1, anon_sym_LBRACK, - STATE(250), 1, + STATE(235), 1, sym_qualified_path, - STATE(626), 1, + STATE(624), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26774,7 +26841,7 @@ static const uint16_t ts_small_parse_table[] = { sym_list_literal, sym_map_literal, sym_boolean, - STATE(258), 11, + STATE(280), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26786,7 +26853,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(259), 13, + STATE(293), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26841,9 +26908,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, ACTIONS(382), 1, anon_sym_LBRACK, - STATE(304), 1, + STATE(313), 1, sym_expression, - STATE(329), 1, + STATE(330), 1, sym_qualified_path, ACTIONS(125), 2, anon_sym_true, @@ -26856,11 +26923,11 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(381), 3, + STATE(393), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(386), 11, + STATE(377), 11, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26872,7 +26939,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(391), 13, + STATE(382), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26891,7 +26958,7 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(394), 1, sym__doc_comment_line, - STATE(227), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, ACTIONS(392), 8, anon_sym_LBRACE, @@ -26940,11 +27007,11 @@ static const uint16_t ts_small_parse_table[] = { [23611] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(400), 1, + ACTIONS(401), 1, sym__doc_comment_line, - STATE(227), 1, + STATE(226), 1, aux_sym_doc_comment_repeat1, - ACTIONS(398), 8, + ACTIONS(399), 8, anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, @@ -26953,7 +27020,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, sym_float, - ACTIONS(396), 34, + ACTIONS(397), 34, anon_sym_namespace, anon_sym_let, anon_sym_mut, @@ -26988,12 +27055,62 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23667] = 3, + [23667] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(407), 1, + anon_sym_COLON_COLON, + ACTIONS(409), 1, + anon_sym_LBRACE, + ACTIONS(412), 1, + anon_sym_LT2, + STATE(232), 1, + aux_sym_qualified_path_repeat1, + STATE(1690), 1, + sym_type_arguments, + ACTIONS(403), 14, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_do, + anon_sym_SLASH, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(405), 21, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [23725] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(403), 10, - ts_builtin_sym_end, + ACTIONS(417), 10, anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, anon_sym_BANG, @@ -27002,7 +27119,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(405), 30, + ACTIONS(415), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -27033,12 +27150,12 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23715] = 3, + [23773] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(403), 10, + ACTIONS(417), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, anon_sym_BANG, @@ -27047,7 +27164,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(405), 30, + ACTIONS(415), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -27078,69 +27195,21 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [23763] = 8, + [23821] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(411), 1, + ACTIONS(423), 1, anon_sym_COLON_COLON, - ACTIONS(413), 1, - anon_sym_LBRACE, - ACTIONS(416), 1, - anon_sym_LT2, STATE(231), 1, aux_sym_qualified_path_repeat1, - STATE(1680), 1, - sym_type_arguments, - ACTIONS(407), 13, - anon_sym_COLON, - anon_sym_LT, - anon_sym_GT, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(409), 21, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [23820] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(411), 1, - anon_sym_COLON_COLON, - STATE(232), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(419), 14, + ACTIONS(419), 15, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -27172,20 +27241,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23870] = 5, + [23872] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(427), 1, + ACTIONS(407), 1, anon_sym_COLON_COLON, - STATE(232), 1, + STATE(231), 1, aux_sym_qualified_path_repeat1, - ACTIONS(423), 14, + ACTIONS(426), 15, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -27194,7 +27264,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(425), 22, + ACTIONS(428), 22, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -27217,7 +27287,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [23920] = 18, + [23923] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -27240,7 +27310,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27264,21 +27334,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(430), 9, + ACTIONS(430), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [23995] = 17, + [23999] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -27295,7 +27368,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27311,8 +27384,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(464), 8, - anon_sym_LBRACE, + ACTIONS(464), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27320,54 +27392,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(462), 9, + ACTIONS(462), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24068] = 12, + [24075] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, + ACTIONS(412), 1, anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(466), 11, + ACTIONS(466), 1, + anon_sym_LBRACE, + STATE(1690), 1, + sym_type_arguments, + ACTIONS(403), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, + anon_sym_SLASH, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(468), 15, - anon_sym_LBRACE, + ACTIONS(405), 22, + sym__call_open_gap, + anon_sym_DOT, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, @@ -27380,28 +27443,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - [24131] = 9, + [24127] = 8, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(454), 1, - anon_sym_PIPE_GT, ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(466), 12, + ACTIONS(469), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_true, anon_sym_false, @@ -27409,7 +27476,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(468), 19, + ACTIONS(471), 20, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -27428,12 +27495,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_PERCENT, + anon_sym_PIPE_GT, sym_float, - [24188] = 18, + [24183] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -27450,9 +27520,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(472), 1, - anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27476,17 +27544,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(470), 9, + ACTIONS(473), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24263] = 18, + [24259] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -27509,7 +27578,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27533,23 +27602,114 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(477), 9, + ACTIONS(477), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24338] = 15, + [24335] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(419), 15, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_do, + anon_sym_SLASH, + anon_sym_LT2, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(421), 23, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [24381] = 9, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(446), 1, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(481), 13, + anon_sym_LT, + anon_sym_GT, + anon_sym__, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_do, + anon_sym_SLASH, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(483), 19, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + sym_float, + [24439] = 12, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, ACTIONS(452), 1, anon_sym_SLASH, ACTIONS(454), 1, @@ -27560,33 +27720,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(466), 9, + ACTIONS(481), 12, + anon_sym_LT, + anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(468), 10, + ACTIONS(483), 15, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -27596,12 +27751,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, sym_float, - [24407] = 14, + [24503] = 15, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(446), 1, + anon_sym_AMP_AMP, ACTIONS(452), 1, anon_sym_SLASH, ACTIONS(454), 1, @@ -27612,7 +27774,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27628,17 +27790,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(466), 9, + ACTIONS(481), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(468), 11, + ACTIONS(483), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -27648,21 +27811,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, sym_float, - [24474] = 18, + [24573] = 14, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, ACTIONS(452), 1, anon_sym_SLASH, ACTIONS(454), 1, @@ -27673,7 +27827,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27689,82 +27843,30 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(483), 7, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - sym_float, - ACTIONS(481), 9, + ACTIONS(481), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24549] = 18, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, + ACTIONS(483), 11, anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(487), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, sym_float, - ACTIONS(485), 9, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [24624] = 11, + [24641] = 11, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -27779,24 +27881,25 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(466), 11, + ACTIONS(481), 12, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(468), 17, + ACTIONS(483), 17, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -27814,7 +27917,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, sym_float, - [24685] = 8, + [24703] = 8, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -27825,14 +27928,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(489), 12, + ACTIONS(485), 13, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_true, anon_sym_false, @@ -27840,7 +27944,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(491), 20, + ACTIONS(487), 20, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -27861,13 +27965,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, sym_float, - [24740] = 18, + [24759] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -27884,7 +27986,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + ACTIONS(491), 1, + anon_sym_LBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27900,7 +28004,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(495), 7, + ACTIONS(494), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27908,21 +28012,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(493), 9, + ACTIONS(489), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24815] = 18, + [24835] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -27939,9 +28046,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(499), 1, - anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27957,7 +28062,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(502), 7, + ACTIONS(498), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -27965,17 +28070,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(497), 9, + ACTIONS(496), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24890] = 18, + [24911] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -27996,9 +28102,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(506), 1, - anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28014,7 +28118,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(509), 7, + ACTIONS(502), 8, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28022,23 +28127,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(504), 9, + ACTIONS(500), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [24965] = 18, + [24985] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -28055,7 +28159,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + ACTIONS(506), 1, + anon_sym_LBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28071,7 +28177,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(513), 7, + ACTIONS(509), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28079,21 +28185,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(511), 9, + ACTIONS(504), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25040] = 17, + [25061] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -28110,7 +28219,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28126,8 +28235,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(517), 8, - anon_sym_LBRACE, + ACTIONS(513), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28135,62 +28243,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(515), 9, + ACTIONS(511), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25113] = 6, + [25137] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(416), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(519), 1, - anon_sym_LBRACE, - STATE(1680), 1, - sym_type_arguments, - ACTIONS(407), 12, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(517), 8, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(515), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, - anon_sym_SLASH, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(409), 22, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [25164] = 18, + [25211] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -28211,9 +28332,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(524), 1, + ACTIONS(521), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28229,7 +28350,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(527), 7, + ACTIONS(524), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28237,21 +28358,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(522), 9, + ACTIONS(519), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25239] = 18, + [25287] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -28268,9 +28392,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(531), 1, - anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28286,7 +28408,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(534), 7, + ACTIONS(528), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28294,23 +28416,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(529), 9, + ACTIONS(526), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25314] = 18, + [25363] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -28327,7 +28448,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + ACTIONS(532), 1, + anon_sym_LBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28343,7 +28466,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(538), 7, + ACTIONS(535), 7, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, @@ -28351,112 +28474,80 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(536), 9, + ACTIONS(530), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25389] = 8, + [25439] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(540), 12, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - anon_sym__, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(542), 20, - anon_sym_LBRACE, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(539), 7, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, sym_float, - [25444] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(423), 14, - anon_sym_COLON, - anon_sym_LT, - anon_sym_GT, + ACTIONS(537), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym_LT2, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(425), 23, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [25489] = 18, + [25515] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -28473,7 +28564,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + ACTIONS(543), 1, + anon_sym_LBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28497,25 +28590,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, sym_float, - ACTIONS(544), 9, + ACTIONS(541), 10, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [25564] = 3, + [25591] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(548), 13, + ACTIONS(548), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28548,15 +28643,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25608] = 3, + [25636] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(552), 13, + ACTIONS(552), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28589,15 +28685,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25652] = 3, + [25681] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(407), 13, + ACTIONS(556), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28606,7 +28703,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(409), 23, + ACTIONS(558), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28630,15 +28727,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25696] = 3, + [25726] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(556), 13, + ACTIONS(560), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28647,7 +28745,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(559), 23, + ACTIONS(562), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28671,15 +28769,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25740] = 3, + [25771] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(562), 13, + ACTIONS(564), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28688,7 +28787,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(564), 23, + ACTIONS(566), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28712,15 +28811,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25784] = 3, + [25816] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(566), 13, + ACTIONS(568), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28729,7 +28829,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(568), 23, + ACTIONS(570), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28753,15 +28853,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25828] = 3, + [25861] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(570), 13, + ACTIONS(572), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28770,7 +28871,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(572), 23, + ACTIONS(574), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28794,15 +28895,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25872] = 3, + [25906] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(574), 13, + ACTIONS(576), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28811,7 +28913,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(576), 23, + ACTIONS(579), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28835,15 +28937,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25916] = 3, + [25951] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(578), 13, + ACTIONS(582), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28852,7 +28955,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(580), 23, + ACTIONS(584), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28876,15 +28979,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [25960] = 3, + [25996] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 13, + ACTIONS(586), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28893,7 +28997,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(584), 23, + ACTIONS(588), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28917,15 +29021,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26004] = 3, + [26041] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(586), 13, + ACTIONS(590), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28934,7 +29039,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(588), 23, + ACTIONS(593), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28958,15 +29063,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26048] = 3, + [26086] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(590), 13, + ACTIONS(596), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -28975,7 +29081,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(592), 23, + ACTIONS(598), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -28999,15 +29105,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26092] = 3, + [26131] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(594), 13, + ACTIONS(600), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29016,7 +29123,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(596), 23, + ACTIONS(602), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29040,15 +29147,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26136] = 3, + [26176] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(598), 13, + ACTIONS(604), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29057,7 +29165,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(600), 23, + ACTIONS(606), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29081,15 +29189,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26180] = 3, + [26221] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(602), 13, + ACTIONS(608), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29098,7 +29207,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(604), 23, + ACTIONS(610), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29122,15 +29231,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26224] = 3, + [26266] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(606), 13, + ACTIONS(612), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29139,7 +29249,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(608), 23, + ACTIONS(614), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29163,15 +29273,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26268] = 3, + [26311] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(610), 13, + ACTIONS(616), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29180,7 +29291,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(612), 23, + ACTIONS(618), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29204,15 +29315,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26312] = 3, + [26356] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(614), 13, + ACTIONS(620), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29221,7 +29333,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(617), 23, + ACTIONS(622), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29245,15 +29357,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26356] = 3, + [26401] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(620), 13, + ACTIONS(624), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29262,7 +29375,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(622), 23, + ACTIONS(626), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29286,15 +29399,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26400] = 3, + [26446] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(624), 13, + ACTIONS(628), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29303,7 +29417,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(626), 23, + ACTIONS(630), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29327,15 +29441,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26444] = 3, + [26491] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(628), 13, + ACTIONS(632), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29344,7 +29459,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(631), 23, + ACTIONS(634), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29368,15 +29483,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26488] = 3, + [26536] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(634), 13, + ACTIONS(636), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29385,7 +29501,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(636), 23, + ACTIONS(638), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29409,15 +29525,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26532] = 3, + [26581] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(638), 13, + ACTIONS(640), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29426,7 +29543,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(640), 23, + ACTIONS(642), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29450,15 +29567,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26576] = 3, + [26626] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(642), 13, + ACTIONS(644), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29467,7 +29585,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(644), 23, + ACTIONS(646), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29491,15 +29609,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26620] = 3, + [26671] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(646), 13, + ACTIONS(648), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29508,7 +29627,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(648), 23, + ACTIONS(651), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29532,15 +29651,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26664] = 3, + [26716] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(650), 13, + ACTIONS(654), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29549,7 +29669,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(652), 23, + ACTIONS(656), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29573,15 +29693,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26708] = 3, + [26761] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(654), 13, + ACTIONS(658), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29590,7 +29711,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(656), 23, + ACTIONS(660), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29614,15 +29735,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26752] = 3, + [26806] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(658), 13, + ACTIONS(662), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29631,7 +29753,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(660), 23, + ACTIONS(664), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29655,15 +29777,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26796] = 3, + [26851] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(662), 13, + ACTIONS(666), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29672,7 +29795,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(664), 23, + ACTIONS(668), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29696,15 +29819,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26840] = 3, + [26896] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(666), 13, + ACTIONS(670), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29713,7 +29837,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(668), 23, + ACTIONS(672), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29737,15 +29861,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26884] = 3, + [26941] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(670), 13, + ACTIONS(674), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29754,7 +29879,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(672), 23, + ACTIONS(676), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29778,15 +29903,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26928] = 3, + [26986] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(674), 13, + ACTIONS(678), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29795,7 +29921,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(676), 23, + ACTIONS(680), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29819,15 +29945,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [26972] = 3, + [27031] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(678), 13, + ACTIONS(682), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29836,7 +29963,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(680), 23, + ACTIONS(684), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29860,15 +29987,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [27016] = 3, + [27076] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(682), 13, + ACTIONS(686), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29877,7 +30005,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(684), 23, + ACTIONS(688), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29901,15 +30029,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [27060] = 3, + [27121] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(686), 13, + ACTIONS(690), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -29918,7 +30047,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(688), 23, + ACTIONS(692), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -29942,61 +30071,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [27104] = 8, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(690), 1, - anon_sym_COLON_COLON, - ACTIONS(692), 1, - anon_sym_LBRACE, - STATE(295), 1, - aux_sym_qualified_path_repeat1, - STATE(1707), 1, - sym_type_arguments, - ACTIONS(407), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 28, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [27158] = 3, + [27166] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(695), 13, + ACTIONS(694), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -30005,7 +30089,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(697), 23, + ACTIONS(696), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -30029,15 +30113,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [27202] = 3, + [27211] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(699), 13, + ACTIONS(403), 14, anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, anon_sym_LBRACK, + anon_sym_do, anon_sym_SLASH, anon_sym_LT2, anon_sym_true, @@ -30046,7 +30131,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(701), 23, + ACTIONS(405), 23, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -30070,22 +30155,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, - [27246] = 5, + [27256] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(690), 1, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(698), 1, anon_sym_COLON_COLON, + ACTIONS(700), 1, + anon_sym_LBRACE, STATE(296), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 4, + STATE(1717), 1, + sym_type_arguments, + ACTIONS(403), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(421), 29, + ACTIONS(405), 28, sym__call_open_gap, anon_sym_DOT, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, anon_sym_let, @@ -30112,19 +30201,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27293] = 5, + [27310] = 5, ACTIONS(3), 1, sym_line_comment, ACTIONS(703), 1, anon_sym_COLON_COLON, - STATE(296), 1, + STATE(295), 1, aux_sym_qualified_path_repeat1, - ACTIONS(423), 4, + ACTIONS(419), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(425), 29, + ACTIONS(421), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -30154,46 +30243,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27340] = 16, + [27357] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(706), 1, - anon_sym_DOT, - ACTIONS(712), 1, - anon_sym_QMARK, - ACTIONS(714), 1, - anon_sym_PIPE_PIPE, - ACTIONS(716), 1, - anon_sym_AMP_AMP, - ACTIONS(722), 1, - anon_sym_SLASH, - ACTIONS(724), 1, - anon_sym_PIPE_GT, - ACTIONS(726), 1, - anon_sym_LBRACK2, - ACTIONS(728), 1, - sym__call_open_gap, - STATE(1644), 1, - sym__call_type_arguments, - ACTIONS(708), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(698), 1, + anon_sym_COLON_COLON, + STATE(295), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(426), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(718), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(464), 14, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(428), 29, + sym__call_open_gap, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30201,51 +30268,63 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27408] = 17, + [27404] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(732), 13, + ACTIONS(710), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -30259,41 +30338,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27478] = 17, + [27474] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30312,41 +30391,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27548] = 17, + [27544] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30365,41 +30444,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27618] = 17, + [27614] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30418,41 +30497,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27688] = 17, + [27684] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30471,41 +30550,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27758] = 17, + [27754] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30524,41 +30603,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27828] = 17, + [27824] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30577,41 +30656,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27898] = 17, + [27894] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30630,41 +30709,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [27968] = 17, + [27964] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30683,41 +30762,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28038] = 17, + [28034] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30736,41 +30815,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28108] = 17, + [28104] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30789,41 +30868,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28178] = 17, + [28174] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30842,41 +30921,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28248] = 17, + [28244] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30895,41 +30974,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28318] = 17, + [28314] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -30948,41 +31027,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28388] = 17, + [28384] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31001,41 +31080,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28458] = 17, + [28454] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31054,41 +31133,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28528] = 17, + [28524] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31107,41 +31186,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28598] = 17, + [28594] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31160,41 +31239,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28668] = 17, + [28664] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31213,41 +31292,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28738] = 17, + [28734] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31266,41 +31345,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28808] = 17, + [28804] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31319,41 +31398,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28878] = 17, + [28874] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31372,41 +31451,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [28948] = 17, + [28944] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31425,41 +31504,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29018] = 17, + [29014] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31478,41 +31557,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29088] = 17, + [29084] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31531,41 +31610,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29158] = 17, + [29154] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31584,41 +31663,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29228] = 17, + [29224] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31637,41 +31716,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29298] = 17, + [29294] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31690,41 +31769,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29368] = 17, + [29364] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31743,41 +31822,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29438] = 17, + [29434] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31796,41 +31875,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29508] = 17, + [29504] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -31849,88 +31928,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29578] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(794), 1, - anon_sym_LBRACE, - STATE(1707), 1, - sym_type_arguments, - ACTIONS(407), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 28, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [29626] = 17, + [29574] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(797), 13, + ACTIONS(794), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -31944,25 +31981,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29696] = 8, + [29644] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, + anon_sym_QMARK, + ACTIONS(718), 1, + anon_sym_PIPE_PIPE, + ACTIONS(720), 1, + anon_sym_AMP_AMP, ACTIONS(726), 1, - anon_sym_LBRACK2, + anon_sym_SLASH, ACTIONS(728), 1, + anon_sym_PIPE_GT, + ACTIONS(730), 1, + anon_sym_LBRACK2, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(540), 3, + ACTIONS(712), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(542), 26, + ACTIONS(724), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(722), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(796), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [29714] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(798), 1, anon_sym_LBRACE, + STATE(1717), 1, + sym_type_arguments, + ACTIONS(403), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(405), 28, + sym__call_open_gap, + anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, anon_sym_let, @@ -31983,51 +32070,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, + anon_sym_LBRACK2, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29748] = 17, + [29762] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(479), 13, + ACTIONS(801), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32041,46 +32129,90 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29818] = 17, + [29832] = 8, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(730), 1, + anon_sym_LBRACK2, + ACTIONS(732), 1, + sym__call_open_gap, + STATE(1654), 1, + sym__call_type_arguments, + ACTIONS(469), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(471), 26, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(714), 1, anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [29884] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(708), 1, + anon_sym_LBRACE, ACTIONS(716), 1, + anon_sym_QMARK, + ACTIONS(718), 1, + anon_sym_PIPE_PIPE, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(495), 13, + ACTIONS(475), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32094,26 +32226,79 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29888] = 9, + [29954] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(724), 1, - anon_sym_PIPE_GT, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, + anon_sym_QMARK, + ACTIONS(718), 1, + anon_sym_PIPE_PIPE, + ACTIONS(720), 1, + anon_sym_AMP_AMP, ACTIONS(726), 1, + anon_sym_SLASH, + ACTIONS(728), 1, + anon_sym_PIPE_GT, + ACTIONS(730), 1, anon_sym_LBRACK2, + ACTIONS(732), 1, + sym__call_open_gap, + STATE(1654), 1, + sym__call_type_arguments, + ACTIONS(712), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(714), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(724), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(722), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(479), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [30024] = 9, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, ACTIONS(728), 1, + anon_sym_PIPE_GT, + ACTIONS(730), 1, + anon_sym_LBRACK2, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(466), 3, + ACTIONS(481), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(468), 25, + ACTIONS(483), 25, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -32139,33 +32324,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [29942] = 12, + [30078] = 12, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(466), 2, + ACTIONS(481), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(468), 21, + ACTIONS(483), 21, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_let, @@ -32187,41 +32372,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30002] = 14, + [30138] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, + ACTIONS(708), 1, + anon_sym_LBRACE, ACTIONS(716), 1, + anon_sym_QMARK, + ACTIONS(718), 1, + anon_sym_PIPE_PIPE, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(468), 16, - anon_sym_LBRACE, + ACTIONS(803), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32230,45 +32420,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30066] = 13, + [30208] = 13, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(468), 17, + ACTIONS(483), 17, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_let, @@ -32286,30 +32474,30 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30128] = 11, + [30270] = 11, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(466), 2, + ACTIONS(481), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(468), 23, + ACTIONS(483), 23, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_let, @@ -32333,24 +32521,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30186] = 8, + [30328] = 8, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(489), 3, + ACTIONS(485), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(491), 26, + ACTIONS(487), 26, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_STAR, @@ -32377,46 +32565,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30238] = 17, + [30380] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(799), 1, + ACTIONS(805), 1, anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(502), 13, + ACTIONS(494), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32430,46 +32618,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30308] = 17, + [30450] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(513), 13, + ACTIONS(498), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32483,44 +32671,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30378] = 16, + [30520] = 16, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(517), 14, + ACTIONS(502), 14, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_let, @@ -32535,46 +32723,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30446] = 17, + [30588] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(802), 1, + ACTIONS(808), 1, anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(534), 13, + ACTIONS(509), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32588,46 +32776,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30516] = 17, + [30658] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(436), 13, + ACTIONS(513), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32641,46 +32829,98 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30586] = 17, + [30728] = 16, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, + STATE(1654), 1, + sym__call_type_arguments, + ACTIONS(712), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(714), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(724), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(722), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(517), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [30796] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(706), 1, + anon_sym_DOT, + ACTIONS(716), 1, + anon_sym_QMARK, + ACTIONS(718), 1, + anon_sym_PIPE_PIPE, + ACTIONS(720), 1, + anon_sym_AMP_AMP, + ACTIONS(726), 1, + anon_sym_SLASH, + ACTIONS(728), 1, + anon_sym_PIPE_GT, ACTIONS(730), 1, + anon_sym_LBRACK2, + ACTIONS(732), 1, + sym__call_open_gap, + ACTIONS(811), 1, anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(805), 13, + ACTIONS(524), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32694,99 +32934,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30656] = 17, + [30866] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, - anon_sym_QMARK, - ACTIONS(714), 1, - anon_sym_PIPE_PIPE, - ACTIONS(716), 1, - anon_sym_AMP_AMP, - ACTIONS(722), 1, - anon_sym_SLASH, - ACTIONS(724), 1, - anon_sym_PIPE_GT, - ACTIONS(726), 1, - anon_sym_LBRACK2, - ACTIONS(728), 1, - sym__call_open_gap, - ACTIONS(807), 1, + ACTIONS(708), 1, anon_sym_LBRACE, - STATE(1644), 1, - sym__call_type_arguments, - ACTIONS(708), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(710), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(720), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(718), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(475), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [30726] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(706), 1, - anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(483), 13, + ACTIONS(528), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32800,46 +32987,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30796] = 17, + [30936] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(487), 13, + ACTIONS(436), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32853,46 +33040,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30866] = 17, + [31006] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(810), 1, + ACTIONS(814), 1, anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(509), 13, + ACTIONS(535), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32906,46 +33093,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [30936] = 17, + [31076] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(538), 13, + ACTIONS(539), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -32959,46 +33146,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31006] = 17, + [31146] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(813), 1, + ACTIONS(817), 1, anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(527), 13, + ACTIONS(546), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -33012,46 +33199,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31076] = 17, + [31216] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(546), 13, + ACTIONS(464), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -33065,46 +33252,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31146] = 17, + [31286] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, + ACTIONS(708), 1, + anon_sym_LBRACE, + ACTIONS(716), 1, anon_sym_QMARK, - ACTIONS(714), 1, + ACTIONS(718), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(816), 13, + ACTIONS(820), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -33118,15 +33305,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31216] = 3, + [31356] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(423), 4, + ACTIONS(419), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(425), 30, + ACTIONS(421), 30, sym__call_open_gap, anon_sym_DOT, anon_sym_COLON_COLON, @@ -33157,46 +33344,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31258] = 17, + [31398] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(706), 1, anon_sym_DOT, - ACTIONS(712), 1, - anon_sym_QMARK, - ACTIONS(714), 1, - anon_sym_PIPE_PIPE, - ACTIONS(716), 1, + ACTIONS(720), 1, anon_sym_AMP_AMP, - ACTIONS(722), 1, + ACTIONS(726), 1, anon_sym_SLASH, - ACTIONS(724), 1, + ACTIONS(728), 1, anon_sym_PIPE_GT, - ACTIONS(726), 1, + ACTIONS(730), 1, anon_sym_LBRACK2, - ACTIONS(728), 1, + ACTIONS(732), 1, sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, + STATE(1654), 1, sym__call_type_arguments, - ACTIONS(708), 2, + ACTIONS(712), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(710), 2, + ACTIONS(714), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(720), 2, + ACTIONS(724), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(718), 4, + ACTIONS(722), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(818), 13, + ACTIONS(483), 16, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -33205,73 +33387,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [31328] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(706), 1, - anon_sym_DOT, - ACTIONS(712), 1, anon_sym_QMARK, - ACTIONS(714), 1, anon_sym_PIPE_PIPE, - ACTIONS(716), 1, - anon_sym_AMP_AMP, - ACTIONS(722), 1, - anon_sym_SLASH, - ACTIONS(724), 1, - anon_sym_PIPE_GT, - ACTIONS(726), 1, - anon_sym_LBRACK2, - ACTIONS(728), 1, - sym__call_open_gap, - ACTIONS(730), 1, - anon_sym_LBRACE, - STATE(1644), 1, - sym__call_type_arguments, - ACTIONS(708), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(710), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(720), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(718), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(820), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31398] = 3, + [31462] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(695), 4, + ACTIONS(648), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(697), 29, + ACTIONS(651), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33301,15 +33432,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31439] = 3, + [31503] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(570), 4, + ACTIONS(572), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(572), 29, + ACTIONS(574), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33339,15 +33470,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31480] = 3, + [31544] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(699), 4, + ACTIONS(576), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(701), 29, + ACTIONS(579), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33377,15 +33508,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31521] = 3, + [31585] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(614), 4, + ACTIONS(582), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(617), 29, + ACTIONS(584), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33415,15 +33546,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31562] = 3, + [31626] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(620), 4, + ACTIONS(586), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(622), 29, + ACTIONS(588), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33453,15 +33584,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31603] = 3, + [31667] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(624), 4, + ACTIONS(590), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(626), 29, + ACTIONS(593), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33491,15 +33622,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31644] = 3, + [31708] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(628), 4, + ACTIONS(596), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(631), 29, + ACTIONS(598), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33529,15 +33660,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31685] = 3, + [31749] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(634), 4, + ACTIONS(556), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(636), 29, + ACTIONS(558), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33567,15 +33698,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31726] = 3, + [31790] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(574), 4, + ACTIONS(604), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(576), 29, + ACTIONS(606), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33605,15 +33736,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31767] = 3, + [31831] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(638), 4, + ACTIONS(608), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(640), 29, + ACTIONS(610), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33643,15 +33774,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31808] = 3, + [31872] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(642), 4, + ACTIONS(612), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(644), 29, + ACTIONS(614), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33681,15 +33812,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31849] = 3, + [31913] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(646), 4, + ACTIONS(568), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(648), 29, + ACTIONS(570), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33719,15 +33850,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31890] = 3, + [31954] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(578), 4, + ACTIONS(620), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(580), 29, + ACTIONS(622), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33757,15 +33888,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31931] = 3, + [31995] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(650), 4, + ACTIONS(600), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(652), 29, + ACTIONS(602), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33795,15 +33926,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [31972] = 3, + [32036] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(582), 4, + ACTIONS(628), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(584), 29, + ACTIONS(630), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33833,15 +33964,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32013] = 3, + [32077] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(654), 4, + ACTIONS(632), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(656), 29, + ACTIONS(634), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33871,15 +34002,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32054] = 3, + [32118] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(658), 4, + ACTIONS(624), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(660), 29, + ACTIONS(626), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33909,15 +34040,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32095] = 3, + [32159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(586), 4, + ACTIONS(640), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(588), 29, + ACTIONS(642), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33947,15 +34078,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32136] = 3, + [32200] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(662), 4, + ACTIONS(548), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(664), 29, + ACTIONS(550), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -33985,15 +34116,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32177] = 3, + [32241] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(590), 4, + ACTIONS(682), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(592), 29, + ACTIONS(684), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34023,15 +34154,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32218] = 3, + [32282] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(556), 4, + ACTIONS(644), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(559), 29, + ACTIONS(646), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34061,15 +34192,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32259] = 3, + [32323] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(548), 4, + ACTIONS(654), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(550), 29, + ACTIONS(656), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34099,15 +34230,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32300] = 3, + [32364] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(666), 4, + ACTIONS(658), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(668), 29, + ACTIONS(660), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34137,15 +34268,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32341] = 3, + [32405] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(670), 4, + ACTIONS(636), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(672), 29, + ACTIONS(638), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34175,15 +34306,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32382] = 3, + [32446] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(610), 4, + ACTIONS(666), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(612), 29, + ACTIONS(668), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34213,15 +34344,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32423] = 3, + [32487] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(674), 4, + ACTIONS(403), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(676), 29, + ACTIONS(405), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34251,15 +34382,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32464] = 3, + [32528] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(678), 4, + ACTIONS(674), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(680), 29, + ACTIONS(676), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34289,15 +34420,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32505] = 3, + [32569] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(562), 4, + ACTIONS(678), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(564), 29, + ACTIONS(680), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34327,15 +34458,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32546] = 3, + [32610] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(682), 4, + ACTIONS(686), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(684), 29, + ACTIONS(688), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34365,15 +34496,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32587] = 3, + [32651] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(552), 4, + ACTIONS(690), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(554), 29, + ACTIONS(692), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34403,15 +34534,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32628] = 3, + [32692] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(686), 4, + ACTIONS(694), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(688), 29, + ACTIONS(696), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34441,15 +34572,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32669] = 3, + [32733] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(566), 4, + ACTIONS(564), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(568), 29, + ACTIONS(566), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34479,15 +34610,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32710] = 3, + [32774] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(598), 4, + ACTIONS(662), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(600), 29, + ACTIONS(664), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34517,15 +34648,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32751] = 3, + [32815] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(594), 4, + ACTIONS(552), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(596), 29, + ACTIONS(554), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34555,15 +34686,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32792] = 3, + [32856] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(407), 4, + ACTIONS(670), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(409), 29, + ACTIONS(672), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34593,15 +34724,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32833] = 3, + [32897] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(602), 4, + ACTIONS(560), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(604), 29, + ACTIONS(562), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34631,15 +34762,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32874] = 3, + [32938] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(606), 4, + ACTIONS(616), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(608), 29, + ACTIONS(618), 29, sym__call_open_gap, anon_sym_DOT, anon_sym_LBRACE, @@ -34669,7 +34800,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [32915] = 18, + [32979] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -34692,7 +34823,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(824), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -34721,7 +34852,7 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [32985] = 18, + [33049] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -34744,7 +34875,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(831), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -34773,14 +34904,14 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - [33055] = 5, + [33119] = 5, ACTIONS(3), 1, sym_line_comment, ACTIONS(836), 1, anon_sym_COLON_COLON, STATE(396), 1, aux_sym_qualified_path_repeat1, - ACTIONS(425), 9, + ACTIONS(421), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LT, @@ -34790,7 +34921,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_PLUS, sym__doc_comment_line, - ACTIONS(423), 18, + ACTIONS(419), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34809,14 +34940,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [33096] = 5, + [33160] = 5, ACTIONS(3), 1, sym_line_comment, ACTIONS(839), 1, anon_sym_COLON_COLON, STATE(396), 1, aux_sym_qualified_path_repeat1, - ACTIONS(421), 8, + ACTIONS(428), 8, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LT, @@ -34825,7 +34956,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_LBRACK, sym__doc_comment_line, - ACTIONS(419), 18, + ACTIONS(426), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34844,10 +34975,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [33136] = 3, + [33200] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(425), 10, + ACTIONS(421), 10, anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34858,7 +34989,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_PLUS, sym__doc_comment_line, - ACTIONS(423), 18, + ACTIONS(419), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34877,10 +35008,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [33172] = 10, + [33236] = 10, ACTIONS(298), 1, sym_line_comment, - ACTIONS(416), 1, + ACTIONS(412), 1, anon_sym_LT2, ACTIONS(841), 1, anon_sym_COLON_COLON, @@ -34890,15 +35021,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(849), 1, anon_sym_EQ, - STATE(438), 1, + STATE(439), 1, aux_sym_qualified_path_repeat1, - STATE(1554), 1, + STATE(1485), 1, sym_type_arguments, - ACTIONS(407), 3, + ACTIONS(403), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(409), 17, + ACTIONS(405), 17, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -34916,7 +35047,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [33221] = 17, + [33285] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -34941,17 +35072,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -34961,7 +35092,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33283] = 17, + [33347] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -34986,17 +35117,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(873), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35006,7 +35137,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33345] = 17, + [33409] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35031,17 +35162,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(875), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(436), 2, + STATE(432), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35051,43 +35182,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33407] = 8, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(841), 1, - anon_sym_COLON_COLON, - ACTIONS(843), 1, - anon_sym_LBRACE, - STATE(438), 1, - aux_sym_qualified_path_repeat1, - STATE(1554), 1, - sym_type_arguments, - ACTIONS(407), 4, - anon_sym_COLON, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 17, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [33451] = 17, + [33471] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35112,17 +35207,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(877), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35132,7 +35227,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33513] = 17, + [33533] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35157,17 +35252,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(879), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(417), 2, + STATE(412), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35177,7 +35272,156 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33575] = 17, + [33595] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(407), 1, + anon_sym_COLON_COLON, + ACTIONS(409), 1, + anon_sym_LBRACE, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(881), 1, + anon_sym_COLON, + STATE(232), 1, + aux_sym_qualified_path_repeat1, + STATE(1690), 1, + sym_type_arguments, + ACTIONS(403), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(405), 17, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33641] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(841), 1, + anon_sym_COLON_COLON, + ACTIONS(843), 1, + anon_sym_LBRACE, + STATE(439), 1, + aux_sym_qualified_path_repeat1, + STATE(1485), 1, + sym_type_arguments, + ACTIONS(403), 4, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(405), 17, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33685] = 11, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(407), 1, + anon_sym_COLON_COLON, + ACTIONS(409), 1, + anon_sym_LBRACE, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(883), 1, + anon_sym_RBRACE, + ACTIONS(886), 1, + anon_sym_COMMA, + STATE(232), 1, + aux_sym_qualified_path_repeat1, + STATE(1218), 1, + aux_sym_field_pattern_repeat1, + STATE(1690), 1, + sym_type_arguments, + ACTIONS(403), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(405), 15, + sym__call_open_gap, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33735] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(412), 1, + anon_sym_LT2, + ACTIONS(841), 1, + anon_sym_COLON_COLON, + ACTIONS(843), 1, + anon_sym_LBRACE, + ACTIONS(849), 1, + anon_sym_EQ, + STATE(439), 1, + aux_sym_qualified_path_repeat1, + STATE(1485), 1, + sym_type_arguments, + ACTIONS(403), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(405), 17, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [33781] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35200,19 +35444,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(881), 1, + ACTIONS(888), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35222,7 +35466,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33637] = 17, + [33843] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35245,19 +35489,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(883), 1, + ACTIONS(890), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(436), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35267,42 +35511,42 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33699] = 17, + [33905] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, + ACTIONS(892), 1, + anon_sym_RBRACE, + ACTIONS(897), 1, anon_sym_fn, - ACTIONS(857), 1, + ACTIONS(900), 1, anon_sym_extern, - ACTIONS(859), 1, + ACTIONS(903), 1, anon_sym_type, - ACTIONS(861), 1, + ACTIONS(906), 1, sym_static_stage, - ACTIONS(863), 1, + ACTIONS(909), 1, anon_sym_effect, - ACTIONS(865), 1, + ACTIONS(912), 1, anon_sym_state, - ACTIONS(867), 1, + ACTIONS(915), 1, anon_sym_module, - ACTIONS(869), 1, + ACTIONS(918), 1, anon_sym_export, - ACTIONS(871), 1, + ACTIONS(921), 1, anon_sym_signature, - ACTIONS(885), 1, - anon_sym_RBRACE, - STATE(226), 1, + ACTIONS(924), 1, + sym__doc_comment_line, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, - ACTIONS(853), 2, + ACTIONS(894), 2, anon_sym_let, anon_sym_mut, - STATE(407), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35312,81 +35556,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [33761] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(411), 1, - anon_sym_COLON_COLON, - ACTIONS(413), 1, - anon_sym_LBRACE, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(887), 1, - anon_sym_COLON, - STATE(231), 1, - aux_sym_qualified_path_repeat1, - STATE(1680), 1, - sym_type_arguments, - ACTIONS(407), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 17, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_STAR, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [33807] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(841), 1, - anon_sym_COLON_COLON, - ACTIONS(843), 1, - anon_sym_LBRACE, - ACTIONS(849), 1, - anon_sym_EQ, - STATE(438), 1, - aux_sym_qualified_path_repeat1, - STATE(1554), 1, - sym_type_arguments, - ACTIONS(407), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 17, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [33853] = 17, + [33967] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35409,185 +35579,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(889), 1, + ACTIONS(927), 1, anon_sym_RBRACE, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(413), 2, - sym_module_item, - aux_sym_module_declaration_repeat1, - STATE(758), 9, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym_export_declaration, - sym__module_declaration, - sym_signature_declaration, - [33915] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(869), 1, - anon_sym_export, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(891), 1, - anon_sym_RBRACE, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(420), 2, - sym_module_item, - aux_sym_module_declaration_repeat1, - STATE(758), 9, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym_export_declaration, - sym__module_declaration, - sym_signature_declaration, - [33977] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(893), 1, - anon_sym_RBRACE, - ACTIONS(898), 1, - anon_sym_fn, - ACTIONS(901), 1, - anon_sym_extern, - ACTIONS(904), 1, - anon_sym_type, - ACTIONS(907), 1, - sym_static_stage, - ACTIONS(910), 1, - anon_sym_effect, - ACTIONS(913), 1, - anon_sym_state, - ACTIONS(916), 1, - anon_sym_module, - ACTIONS(919), 1, - anon_sym_export, - ACTIONS(922), 1, - anon_sym_signature, - ACTIONS(925), 1, - sym__doc_comment_line, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(895), 2, - anon_sym_let, - anon_sym_mut, - STATE(413), 2, - sym_module_item, - aux_sym_module_declaration_repeat1, - STATE(758), 9, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym_export_declaration, - sym__module_declaration, - sym_signature_declaration, - [34039] = 11, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(411), 1, - anon_sym_COLON_COLON, - ACTIONS(413), 1, - anon_sym_LBRACE, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(928), 1, - anon_sym_RBRACE, - ACTIONS(931), 1, - anon_sym_COMMA, - STATE(231), 1, - aux_sym_qualified_path_repeat1, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, - STATE(1680), 1, - sym_type_arguments, - ACTIONS(407), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 15, - sym__call_open_gap, - anon_sym_DOT, - anon_sym_STAR, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [34089] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(869), 1, - anon_sym_export, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(933), 1, - anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35595,7 +35591,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35605,7 +35601,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34151] = 17, + [34029] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35628,11 +35624,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(935), 1, + ACTIONS(929), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35640,97 +35636,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(401), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym_export_declaration, - sym__module_declaration, - sym_signature_declaration, - [34213] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(869), 1, - anon_sym_export, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(937), 1, - anon_sym_RBRACE, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(413), 2, - sym_module_item, - aux_sym_module_declaration_repeat1, - STATE(758), 9, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym_export_declaration, - sym__module_declaration, - sym_signature_declaration, - [34275] = 17, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(869), 1, - anon_sym_export, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(939), 1, - anon_sym_RBRACE, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(820), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(406), 2, - sym_module_item, - aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35740,7 +35646,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34337] = 17, + [34091] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35763,19 +35669,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(941), 1, + ACTIONS(931), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(404), 2, + STATE(419), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35785,7 +35691,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34399] = 17, + [34153] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35808,19 +35714,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(943), 1, + ACTIONS(933), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(400), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35830,7 +35736,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34461] = 17, + [34215] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35853,19 +35759,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(945), 1, + ACTIONS(935), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(423), 2, + STATE(420), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35875,7 +35781,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34523] = 17, + [34277] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35898,19 +35804,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(947), 1, + ACTIONS(937), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(426), 2, + STATE(422), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35920,7 +35826,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34585] = 17, + [34339] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35943,19 +35849,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(949), 1, + ACTIONS(939), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(424), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -35965,7 +35871,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34647] = 17, + [34401] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -35988,19 +35894,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(951), 1, + ACTIONS(941), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(400), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36010,7 +35916,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34709] = 17, + [34463] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36033,19 +35939,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(953), 1, + ACTIONS(943), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(429), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36055,7 +35961,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34771] = 17, + [34525] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36078,19 +35984,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(955), 1, + ACTIONS(945), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(427), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36100,7 +36006,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34833] = 17, + [34587] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36123,19 +36029,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(957), 1, + ACTIONS(947), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(431), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36145,7 +36051,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34895] = 17, + [34649] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36168,19 +36074,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(959), 1, + ACTIONS(949), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(432), 2, + STATE(428), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36190,7 +36096,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [34957] = 17, + [34711] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36213,19 +36119,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(961), 1, + ACTIONS(951), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36235,7 +36141,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35019] = 17, + [34773] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36258,19 +36164,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(963), 1, + ACTIONS(953), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(434), 2, + STATE(430), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36280,7 +36186,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35081] = 17, + [34835] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36303,19 +36209,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(965), 1, + ACTIONS(955), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(435), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36325,7 +36231,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35143] = 17, + [34897] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36348,19 +36254,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(967), 1, + ACTIONS(957), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36370,7 +36276,232 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35205] = 17, + [34959] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(869), 1, + anon_sym_export, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(959), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(812), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(411), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(751), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [35021] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(869), 1, + anon_sym_export, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(961), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(812), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(431), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(751), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [35083] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(869), 1, + anon_sym_export, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(963), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(812), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(411), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(751), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [35145] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(869), 1, + anon_sym_export, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(965), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(812), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(411), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(751), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [35207] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(869), 1, + anon_sym_export, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(967), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(812), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(411), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(751), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [35269] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36395,17 +36526,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(969), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(435), 2, + STATE(403), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36415,7 +36546,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35267] = 17, + [35331] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36440,17 +36571,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(971), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(409), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36460,7 +36591,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35329] = 17, + [35393] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36485,17 +36616,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(973), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36505,7 +36636,7 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35391] = 17, + [35455] = 17, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -36530,17 +36661,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, ACTIONS(975), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(820), 1, + STATE(812), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(413), 2, + STATE(411), 2, sym_module_item, aux_sym_module_declaration_repeat1, - STATE(758), 9, + STATE(751), 9, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -36550,20 +36681,54 @@ static const uint16_t ts_small_parse_table[] = { sym_export_declaration, sym__module_declaration, sym_signature_declaration, - [35453] = 5, + [35517] = 7, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + ACTIONS(981), 1, + anon_sym_LT, + ACTIONS(983), 1, + anon_sym_LBRACK, + STATE(397), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(979), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(977), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [35558] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(977), 1, + ACTIONS(985), 1, anon_sym_COLON_COLON, - STATE(437), 1, + STATE(438), 1, aux_sym_qualified_path_repeat1, - ACTIONS(423), 5, + ACTIONS(419), 5, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(425), 18, + ACTIONS(421), 18, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36582,20 +36747,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35490] = 5, + [35595] = 5, ACTIONS(298), 1, sym_line_comment, ACTIONS(841), 1, anon_sym_COLON_COLON, - STATE(437), 1, + STATE(438), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 5, + ACTIONS(426), 5, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(421), 18, + ACTIONS(428), 18, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36614,138 +36779,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35527] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(839), 1, - anon_sym_COLON_COLON, - ACTIONS(984), 1, - anon_sym_LT, - ACTIONS(986), 1, - anon_sym_LBRACK, - STATE(397), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(982), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(980), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [35568] = 19, - ACTIONS(131), 1, - anon_sym_RBRACE, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(994), 1, - anon_sym_COLON, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, - sym__statement_break, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35632] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(479), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35692] = 3, + [35632] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(423), 5, + ACTIONS(419), 5, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(425), 19, + ACTIONS(421), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -36765,50 +36808,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [35724] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1018), 1, - anon_sym_LBRACE, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(475), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [35784] = 19, + [35664] = 19, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -36831,13 +36831,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1021), 1, + ACTIONS(988), 1, anon_sym_COMMA, - ACTIONS(1023), 1, + ACTIONS(990), 1, anon_sym_RPAREN, - STATE(1216), 1, + STATE(1157), 1, aux_sym_argument_list_repeat1, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -36853,372 +36853,359 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35848] = 17, + [35728] = 8, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - ACTIONS(1025), 1, - anon_sym_LBRACE, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(469), 3, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(527), 3, + anon_sym_SLASH, + ACTIONS(471), 16, sym__statement_break, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COLON, - ACTIONS(1004), 4, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35908] = 17, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + [35770] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, ACTIONS(998), 1, + anon_sym_LBRACE, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(483), 3, + ACTIONS(524), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [35968] = 17, + [35830] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(495), 3, + ACTIONS(479), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36028] = 17, + [35890] = 19, + ACTIONS(234), 1, + anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1021), 1, + anon_sym_COLON, + ACTIONS(1023), 1, + sym__statement_break, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1028), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36088] = 17, + [35954] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1030), 1, - anon_sym_LBRACE, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 3, + ACTIONS(502), 4, sym__statement_break, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36148] = 17, + [36012] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(487), 3, + ACTIONS(513), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36208] = 17, + [36072] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1033), 1, + ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(509), 3, + ACTIONS(475), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36268] = 19, - ACTIONS(240), 1, - anon_sym_RBRACE, + [36132] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, ACTIONS(994), 1, - anon_sym_COLON, - ACTIONS(998), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, - sym__statement_break, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(528), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36332] = 8, + [36192] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, + ACTIONS(412), 1, anon_sym_LT2, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(540), 3, + ACTIONS(1025), 1, + anon_sym_LBRACE, + STATE(1485), 1, + sym_type_arguments, + ACTIONS(403), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(542), 16, + ACTIONS(405), 18, + sym__call_open_gap, sym__statement_break, - anon_sym_LBRACE, + anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, anon_sym_COLON, @@ -37233,134 +37220,137 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_PERCENT, anon_sym_PIPE_GT, - [36374] = 16, + anon_sym_LBRACK2, + [36230] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(517), 4, + ACTIONS(498), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36432] = 16, + [36290] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1028), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(464), 4, + ACTIONS(494), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36490] = 17, + [36350] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(513), 3, - sym__statement_break, - anon_sym_RBRACE, - anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1031), 3, + anon_sym_in, + anon_sym_do, + sym_identifier, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36550] = 19, + [36410] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -37383,13 +37373,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1021), 1, - anon_sym_COMMA, - ACTIONS(1036), 1, - anon_sym_RBRACK, - STATE(1231), 1, - aux_sym_argument_list_repeat1, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37400,261 +37384,356 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, + ACTIONS(1033), 3, + anon_sym_in, + anon_sym_do, + sym_identifier, ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36614] = 17, + [36470] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(538), 3, + ACTIONS(436), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36674] = 17, + [36530] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(436), 3, + ACTIONS(517), 4, sym__statement_break, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36734] = 6, + [36588] = 19, ACTIONS(298), 1, sym_line_comment, - ACTIONS(416), 1, - anon_sym_LT2, - ACTIONS(1038), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - STATE(1554), 1, - sym_type_arguments, - ACTIONS(407), 3, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(988), 1, + anon_sym_COMMA, + ACTIONS(1035), 1, + anon_sym_RBRACK, + STATE(1217), 1, + aux_sym_argument_list_repeat1, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(409), 18, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [36652] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, sym__call_open_gap, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(483), 6, sym__statement_break, - anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + [36706] = 13, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [36772] = 17, + ACTIONS(483), 7, + sym__statement_break, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + [36758] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1041), 1, + ACTIONS(1037), 1, anon_sym_LBRACE, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(502), 3, + ACTIONS(509), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36832] = 17, + [36818] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1040), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(546), 3, + ACTIONS(535), 3, sym__statement_break, anon_sym_RBRACE, anon_sym_COLON, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36892] = 19, - ACTIONS(248), 1, + [36878] = 19, + ACTIONS(250), 1, anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, ACTIONS(994), 1, - anon_sym_COLON, - ACTIONS(998), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1021), 1, + anon_sym_COLON, + ACTIONS(1023), 1, sym__statement_break, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [36956] = 19, + [36942] = 19, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -37677,13 +37756,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1021), 1, + ACTIONS(988), 1, anon_sym_COMMA, - ACTIONS(1044), 1, + ACTIONS(1043), 1, anon_sym_RBRACK, - STATE(1180), 1, + STATE(1138), 1, aux_sym_argument_list_repeat1, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37699,26 +37778,104 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37020] = 9, + [37006] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(539), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [37066] = 11, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(1010), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(481), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(483), 13, + sym__statement_break, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + [37114] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(466), 3, + ACTIONS(485), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(468), 15, + ACTIONS(487), 16, sym__statement_break, anon_sym_LBRACE, anon_sym_RBRACE, @@ -37734,45 +37891,96 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_PERCENT, - [37064] = 12, + anon_sym_PIPE_GT, + [37156] = 19, + ACTIONS(244), 1, + anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1021), 1, + anon_sym_COLON, + ACTIONS(1023), 1, + sym__statement_break, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(466), 2, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(992), 2, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [37220] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1045), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1006), 2, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(468), 11, + ACTIONS(546), 3, sym__statement_break, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37114] = 19, + [37280] = 19, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -37795,13 +38003,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1021), 1, + ACTIONS(988), 1, anon_sym_COMMA, - ACTIONS(1046), 1, + ACTIONS(1048), 1, anon_sym_RBRACK, - STATE(1164), 1, + STATE(1133), 1, aux_sym_argument_list_repeat1, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37817,112 +38025,73 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37178] = 14, + [37344] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(468), 6, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(1005), 1, anon_sym_QMARK, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - [37232] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(1008), 1, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(464), 3, + sym__statement_break, + anon_sym_RBRACE, + anon_sym_COLON, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(468), 7, - sym__statement_break, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - [37284] = 11, + [37404] = 9, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(466), 2, + ACTIONS(481), 3, anon_sym_LT, anon_sym_GT, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(468), 13, + anon_sym_SLASH, + ACTIONS(483), 15, sym__statement_break, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, @@ -37933,28 +38102,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - [37332] = 8, + anon_sym_PERCENT, + [37448] = 12, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(489), 3, + ACTIONS(481), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(491), 16, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(483), 11, sym__statement_break, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_COLON, anon_sym_QMARK, anon_sym_PIPE_PIPE, @@ -37963,11 +38141,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - [37374] = 17, + [37498] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -37990,7 +38164,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38001,23 +38175,24 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1048), 2, - anon_sym_RBRACE, + ACTIONS(1050), 3, anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37433] = 3, + [37558] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(552), 4, + ACTIONS(674), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(554), 19, + ACTIONS(676), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38037,7 +38212,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37464] = 3, + [37589] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(654), 4, @@ -38065,15 +38240,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37495] = 3, + [37620] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(695), 4, + ACTIONS(658), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(697), 19, + ACTIONS(660), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38093,99 +38268,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37526] = 3, + [37651] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(658), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(660), 19, - sym__call_open_gap, - sym__statement_break, + ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, + ACTIONS(442), 1, anon_sym_QMARK, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, + ACTIONS(446), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, - [37557] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(610), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, + ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(612), 19, + ACTIONS(460), 1, sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37588] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(598), 4, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(600), 19, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_LBRACE, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1052), 2, anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_COMMA, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37619] = 3, + [37710] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(562), 4, + ACTIONS(576), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(564), 19, + ACTIONS(579), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38205,15 +38338,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37650] = 3, + [37741] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(638), 4, + ACTIONS(582), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(640), 19, + ACTIONS(584), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38233,127 +38366,140 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37681] = 3, + [37772] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(662), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(664), 19, - sym__call_open_gap, - sym__statement_break, + ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, + ACTIONS(442), 1, anon_sym_QMARK, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, + ACTIONS(446), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, anon_sym_PIPE_GT, + ACTIONS(456), 1, anon_sym_LBRACK2, - [37712] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(642), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, + ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(644), 19, + ACTIONS(460), 1, sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1054), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37743] = 3, + [37831] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(699), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, + ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(701), 19, - sym__call_open_gap, - sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_COLON, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37774] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(586), 4, - anon_sym_LT, - anon_sym_GT, + ACTIONS(1015), 1, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(588), 19, - sym__call_open_gap, - sym__statement_break, - anon_sym_DOT, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, anon_sym_LBRACE, + ACTIONS(1023), 1, + sym__statement_break, + ACTIONS(1056), 1, anon_sym_RBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, anon_sym_STAR, - anon_sym_COLON, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + [37892] = 15, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1058), 1, + sym_identifier, + ACTIONS(1060), 1, + anon_sym_LBRACE, + ACTIONS(1062), 1, + anon_sym_RBRACE, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + STATE(1282), 1, + sym_qualified_path, + STATE(1666), 1, + sym_pattern, + STATE(1736), 1, + sym_field_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [37805] = 3, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + STATE(553), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [37947] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(614), 4, + ACTIONS(596), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(617), 19, + ACTIONS(598), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38373,15 +38519,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37836] = 3, + [37978] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(646), 4, + ACTIONS(670), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(648), 19, + ACTIONS(672), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38401,15 +38547,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37867] = 3, + [38009] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(670), 4, + ACTIONS(640), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(672), 19, + ACTIONS(642), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38429,15 +38575,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37898] = 3, + [38040] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 4, + ACTIONS(604), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(584), 19, + ACTIONS(606), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38457,98 +38603,86 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [37929] = 18, - ACTIONS(244), 1, + [38071] = 18, + ACTIONS(248), 1, anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, sym__statement_break, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [37990] = 15, + [38132] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1050), 1, - sym_identifier, - ACTIONS(1052), 1, + ACTIONS(636), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(638), 19, + sym__call_open_gap, + sym__statement_break, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1054), 1, anon_sym_RBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - STATE(1332), 1, - sym_qualified_path, - STATE(1360), 1, - sym_field_pattern, - STATE(1507), 1, - sym_pattern, - ACTIONS(1062), 2, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - STATE(594), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [38045] = 3, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [38163] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(566), 4, + ACTIONS(682), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(568), 19, + ACTIONS(684), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38568,15 +38702,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38076] = 3, + [38194] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(620), 4, + ACTIONS(568), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(622), 19, + ACTIONS(570), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38596,15 +38730,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38107] = 3, + [38225] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(407), 4, + ACTIONS(608), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(409), 19, + ACTIONS(610), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38624,15 +38758,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38138] = 3, + [38256] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(570), 4, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1076), 2, + anon_sym_in, + sym_identifier, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [38315] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(620), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(572), 19, + ACTIONS(622), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38652,15 +38828,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38169] = 3, + [38346] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(574), 4, + ACTIONS(612), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(576), 19, + ACTIONS(614), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38680,7 +38856,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38200] = 17, + [38377] = 18, + ACTIONS(242), 1, + anon_sym_RBRACE, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, + sym__statement_break, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [38438] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -38703,7 +38922,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38714,7 +38933,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1068), 2, + ACTIONS(1078), 2, anon_sym_RBRACE, anon_sym_COMMA, ACTIONS(448), 4, @@ -38722,15 +38941,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38259] = 3, + [38497] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(624), 4, + ACTIONS(628), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(626), 19, + ACTIONS(630), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38750,7 +38969,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38290] = 17, + [38528] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -38773,7 +38992,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38784,7 +39003,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1070), 2, + ACTIONS(1080), 2, anon_sym_in, sym_identifier, ACTIONS(448), 4, @@ -38792,15 +39011,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38349] = 3, + [38587] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(650), 4, + ACTIONS(586), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(652), 19, + ACTIONS(588), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38820,15 +39039,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38380] = 3, + [38618] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(674), 4, + ACTIONS(690), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(676), 19, + ACTIONS(692), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38848,15 +39067,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38411] = 3, + [38649] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(678), 4, + ACTIONS(552), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(680), 19, + ACTIONS(554), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -38876,255 +39095,71 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38442] = 17, + [38680] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(644), 4, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1072), 2, - anon_sym_in, - sym_identifier, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [38501] = 5, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(984), 1, - anon_sym_LT, - ACTIONS(986), 1, - anon_sym_LBRACK, - ACTIONS(982), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(980), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [38536] = 18, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, + anon_sym_SLASH, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(646), 19, + sym__call_open_gap, + sym__statement_break, anon_sym_DOT, - ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, - sym__statement_break, - ACTIONS(1074), 1, - anon_sym_RBRACE, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38597] = 15, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1050), 1, - sym_identifier, - ACTIONS(1052), 1, - anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - ACTIONS(1076), 1, - anon_sym_RBRACE, - STATE(1332), 1, - sym_qualified_path, - STATE(1360), 1, - sym_field_pattern, - STATE(1507), 1, - sym_pattern, - ACTIONS(1062), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - STATE(551), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [38652] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1078), 2, - anon_sym_in, - sym_identifier, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [38711] = 18, + [38711] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, + ACTIONS(560), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(562), 19, + sym__call_open_gap, + sym__statement_break, anon_sym_DOT, - ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, - sym__statement_break, - ACTIONS(1080), 1, - anon_sym_RBRACE, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38772] = 3, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [38742] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(548), 4, + ACTIONS(632), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(550), 19, + ACTIONS(634), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39144,15 +39179,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38803] = 3, + [38773] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(666), 4, + ACTIONS(548), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(668), 19, + ACTIONS(550), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39172,15 +39207,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38834] = 3, + [38804] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(606), 4, + ACTIONS(600), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(608), 19, + ACTIONS(602), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39200,100 +39235,98 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [38865] = 18, - ACTIONS(242), 1, - anon_sym_RBRACE, + [38835] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, sym__statement_break, - STATE(1362), 1, + ACTIONS(1082), 1, + anon_sym_RBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [38926] = 17, + [38896] = 15, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, + ACTIONS(1058), 1, + sym_identifier, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1084), 1, + anon_sym_RBRACE, + STATE(1282), 1, + sym_qualified_path, + STATE(1666), 1, + sym_pattern, + STATE(1736), 1, + sym_field_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1082), 2, - anon_sym_in, - sym_identifier, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [38985] = 3, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + STATE(583), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [38951] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(628), 4, + ACTIONS(666), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(631), 19, + ACTIONS(668), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39313,15 +39346,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39016] = 3, + [38982] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(556), 4, + ACTIONS(616), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(559), 19, + ACTIONS(618), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39341,15 +39374,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39047] = 3, + [39013] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(682), 4, + ACTIONS(694), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(684), 19, + ACTIONS(696), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39369,15 +39402,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39078] = 3, + [39044] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(578), 4, + ACTIONS(678), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(580), 19, + ACTIONS(680), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39397,7 +39430,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39109] = 3, + [39075] = 18, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, + sym__statement_break, + ACTIONS(1086), 1, + anon_sym_RBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [39136] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(590), 4, @@ -39405,7 +39481,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(592), 19, + ACTIONS(593), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39425,226 +39501,283 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39140] = 17, + [39167] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, + sym__statement_break, + ACTIONS(1088), 1, + anon_sym_RBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1084), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39199] = 18, + [39228] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, + ACTIONS(572), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(574), 19, + sym__call_open_gap, + sym__statement_break, anon_sym_DOT, - ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + [39259] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(556), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(558), 19, sym__call_open_gap, - ACTIONS(1016), 1, sym__statement_break, - ACTIONS(1086), 1, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39260] = 15, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39290] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(981), 1, + anon_sym_LT, + ACTIONS(983), 1, + anon_sym_LBRACK, + ACTIONS(979), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(977), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [39325] = 15, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1050), 1, + ACTIONS(1058), 1, sym_identifier, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1088), 1, + ACTIONS(1090), 1, anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1360), 1, - sym_field_pattern, - STATE(1507), 1, + STATE(1666), 1, sym_pattern, - ACTIONS(1062), 2, + STATE(1736), 1, + sym_field_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(580), 2, + STATE(558), 2, sym_match_arm, aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [39315] = 18, + [39380] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, + ACTIONS(648), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(651), 19, + sym__call_open_gap, + sym__statement_break, anon_sym_DOT, - ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_QMARK, - ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + [39411] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(686), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + anon_sym_LT2, + ACTIONS(688), 19, sym__call_open_gap, - ACTIONS(1016), 1, sym__statement_break, - ACTIONS(1090), 1, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_RBRACE, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39376] = 18, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [39442] = 18, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1016), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, sym__statement_break, ACTIONS(1092), 1, anon_sym_RBRACE, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39437] = 3, + [39503] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(686), 4, + ACTIONS(624), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(688), 19, + ACTIONS(626), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39664,15 +39797,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39468] = 3, + [39534] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(634), 4, + ACTIONS(662), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(636), 19, + ACTIONS(664), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39692,15 +39825,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39499] = 3, + [39565] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(594), 4, + ACTIONS(403), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(596), 19, + ACTIONS(405), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39720,15 +39853,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39530] = 3, + [39596] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(602), 4, + ACTIONS(564), 4, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, anon_sym_LT2, - ACTIONS(604), 19, + ACTIONS(566), 19, sym__call_open_gap, sym__statement_break, anon_sym_DOT, @@ -39748,496 +39881,565 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [39561] = 17, + [39627] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(770), 1, + ACTIONS(803), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39619] = 17, + [39685] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(805), 1, - sym__statement_break, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(1094), 1, + sym_identifier, + ACTIONS(1097), 1, anon_sym_LBRACE, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1100), 1, + anon_sym_RBRACE, + ACTIONS(1102), 1, + anon_sym_LPAREN, + ACTIONS(1108), 1, + anon_sym_LBRACK, + ACTIONS(1117), 1, + sym_float, + STATE(1282), 1, + sym_qualified_path, + STATE(1666), 1, + sym_pattern, + ACTIONS(1111), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1114), 2, + anon_sym_true, + anon_sym_false, + STATE(528), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1105), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [39737] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(796), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39677] = 17, + [39795] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(784), 1, + ACTIONS(764), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39735] = 17, + [39853] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(742), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1094), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39793] = 17, + [39911] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(820), 1, + ACTIONS(766), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39851] = 17, + [39969] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(774), 1, + ACTIONS(756), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39909] = 17, + [40027] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, + ACTIONS(1120), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(644), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(646), 16, + sym__call_open_gap, anon_sym_DOT, - ACTIONS(990), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + anon_sym_STAR, anon_sym_QMARK, - ACTIONS(1000), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(1012), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + [40059] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, sym__call_open_gap, - ACTIONS(1016), 1, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1122), 1, sym__statement_break, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39967] = 17, + [40117] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(750), 1, + ACTIONS(768), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40025] = 17, + [40175] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(776), 1, + ACTIONS(770), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40083] = 17, + [40233] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(786), 1, + ACTIONS(754), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40141] = 17, + [40291] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(732), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1124), 1, + anon_sym_COLON, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40199] = 14, + [40349] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1096), 1, - sym_identifier, - ACTIONS(1099), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(772), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(1102), 1, - anon_sym_RBRACE, - ACTIONS(1104), 1, - anon_sym_LPAREN, - ACTIONS(1110), 1, - anon_sym_LBRACK, - ACTIONS(1119), 1, - sym_float, - STATE(1332), 1, - sym_qualified_path, - STATE(1507), 1, - sym_pattern, - ACTIONS(1113), 2, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1116), 2, - anon_sym_true, - anon_sym_false, - STATE(538), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(1107), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [40251] = 17, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [40407] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40260,9 +40462,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1122), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1021), 1, + anon_sym_COLON, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40278,86 +40480,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40309] = 14, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1124), 1, - sym_identifier, - ACTIONS(1127), 1, - anon_sym_LBRACE, - ACTIONS(1130), 1, - anon_sym_RBRACE, - ACTIONS(1132), 1, - anon_sym_LPAREN, - ACTIONS(1138), 1, - anon_sym_LBRACK, - ACTIONS(1147), 1, - sym_float, - STATE(1332), 1, - sym_qualified_path, - STATE(1599), 1, - sym_pattern, - ACTIONS(1141), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1144), 2, - anon_sym_true, - anon_sym_false, - STATE(540), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(1135), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [40361] = 17, + [40465] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(797), 1, + ACTIONS(758), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40419] = 17, + [40523] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40380,9 +40544,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1150), 1, - anon_sym_RBRACE, - STATE(1564), 1, + ACTIONS(1126), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40398,45 +40562,86 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40477] = 14, + [40581] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(774), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [40639] = 14, + ACTIONS(298), 1, + sym_line_comment, ACTIONS(1060), 1, + anon_sym_LBRACE, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - ACTIONS(1154), 1, + ACTIONS(1130), 1, anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1599), 1, + STATE(1470), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(540), 2, + STATE(598), 2, sym_select_arm, aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [40529] = 17, + [40691] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40459,9 +40664,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1156), 1, + ACTIONS(1132), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40477,7 +40682,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40587] = 17, + [40749] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40500,9 +40705,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1158), 1, + ACTIONS(1134), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40518,7 +40723,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40645] = 17, + [40807] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40541,9 +40746,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1160), 1, + ACTIONS(1136), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40559,46 +40764,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40703] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(1162), 1, - anon_sym_opaque, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(828), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(696), 8, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym__module_declaration, - sym_signature_declaration, - [40757] = 17, + [40865] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40621,9 +40787,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1164), 1, + ACTIONS(1138), 1, anon_sym_COLON, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40639,7 +40805,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40815] = 17, + [40923] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40662,9 +40828,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1166), 1, - anon_sym_RBRACK, - STATE(1564), 1, + ACTIONS(1140), 1, + anon_sym_COLON, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40680,127 +40846,165 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40873] = 17, + [40981] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1168), 1, - sym__statement_break, - STATE(1362), 1, + ACTIONS(1142), 1, + anon_sym_RBRACK, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40931] = 14, + [41039] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1128), 1, + sym_identifier, + ACTIONS(1144), 1, + anon_sym_RBRACE, + STATE(1282), 1, + sym_qualified_path, + STATE(1470), 1, + sym_pattern, + ACTIONS(1070), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + STATE(598), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [41091] = 14, + ACTIONS(298), 1, + sym_line_comment, ACTIONS(1060), 1, + anon_sym_LBRACE, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - ACTIONS(1170), 1, + ACTIONS(1146), 1, anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1507), 1, + STATE(1666), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(538), 2, + STATE(528), 2, sym_match_arm, aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [40983] = 17, + [41143] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(734), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1148), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41041] = 17, + [41201] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40823,9 +41027,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1172), 1, + ACTIONS(1150), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40841,171 +41045,248 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41099] = 17, + [41259] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(816), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1152), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41157] = 17, + [41317] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(778), 1, + ACTIONS(776), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41215] = 17, + [41375] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1128), 1, + sym_identifier, + ACTIONS(1154), 1, + anon_sym_RBRACE, + STATE(1282), 1, + sym_qualified_path, + STATE(1666), 1, + sym_pattern, + ACTIONS(1070), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + STATE(528), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [41427] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(1156), 1, + anon_sym_opaque, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(839), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(714), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [41481] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(710), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1174), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41273] = 17, + [41539] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(788), 1, + ACTIONS(801), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41331] = 17, + [41597] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41028,9 +41309,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1176), 1, - anon_sym_COMMA, - STATE(1564), 1, + ACTIONS(1158), 1, + anon_sym_RBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41046,48 +41327,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41389] = 17, + [41655] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(780), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1160), 1, + anon_sym_COLON, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41447] = 17, + [41713] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41110,9 +41391,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1178), 1, - anon_sym_COLON, - STATE(1564), 1, + ACTIONS(1162), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41128,7 +41409,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41505] = 17, + [41771] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(752), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [41829] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41151,9 +41473,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1180), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1164), 1, + anon_sym_RBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41169,7 +41491,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41563] = 17, + [41887] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41192,9 +41514,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1182), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1166), 1, + anon_sym_COMMA, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41210,7 +41532,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41621] = 17, + [41945] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41233,9 +41555,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1184), 1, - anon_sym_RBRACE, - STATE(1564), 1, + ACTIONS(1168), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41251,89 +41573,89 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41679] = 17, + [42003] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(736), 1, + ACTIONS(734), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41737] = 17, + [42061] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(790), 1, + ACTIONS(740), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41795] = 17, + [42119] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41356,9 +41678,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1186), 1, - anon_sym_RBRACE, - STATE(1564), 1, + ACTIONS(1170), 1, + anon_sym_RPAREN, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41374,48 +41696,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41853] = 17, + [42177] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(772), 1, + ACTIONS(780), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41911] = 17, + [42235] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41438,9 +41760,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1188), 1, + ACTIONS(1172), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41456,168 +41778,86 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41969] = 17, + [42293] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(740), 1, + ACTIONS(782), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [42027] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(742), 1, - sym__statement_break, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [42085] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, + ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(994), 1, - anon_sym_COLON, - STATE(1564), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42143] = 14, + [42351] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - ACTIONS(1190), 1, + ACTIONS(1174), 1, anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1599), 1, + STATE(1470), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(540), 2, + STATE(598), 2, sym_select_arm, aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [42195] = 17, + [42403] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41640,9 +41880,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1192), 1, + ACTIONS(1176), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41658,7 +41898,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42253] = 17, + [42461] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41681,9 +41921,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1194), 1, + ACTIONS(1178), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41699,7 +41939,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42311] = 17, + [42519] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41722,9 +41962,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1196), 1, + ACTIONS(1180), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41740,48 +41980,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42369] = 17, + [42577] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(784), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1198), 1, - anon_sym_COLON, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42427] = 17, + [42635] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41804,9 +42044,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1200), 1, + ACTIONS(1182), 1, anon_sym_COLON, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41822,7 +42062,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42485] = 17, + [42693] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41845,9 +42085,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1202), 1, + ACTIONS(1184), 1, anon_sym_RBRACK, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41863,86 +42103,86 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42543] = 17, + [42751] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(744), 1, + ACTIONS(778), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42601] = 14, + [42809] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - ACTIONS(1204), 1, + ACTIONS(1186), 1, anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1507), 1, + STATE(1666), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(538), 2, + STATE(528), 2, sym_match_arm, aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [42653] = 17, + [42861] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41965,9 +42205,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1206), 1, + ACTIONS(1188), 1, anon_sym_RPAREN, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41983,86 +42223,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42711] = 14, + [42919] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, - anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - ACTIONS(1152), 1, - sym_identifier, - ACTIONS(1208), 1, - anon_sym_RBRACE, - STATE(1332), 1, - sym_qualified_path, - STATE(1599), 1, - sym_pattern, - ACTIONS(1062), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - STATE(540), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [42763] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(786), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1210), 1, - anon_sym_RPAREN, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42821] = 17, + [42977] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42085,9 +42287,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1212), 1, + ACTIONS(1190), 1, anon_sym_COLON, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42103,7 +42305,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42879] = 17, + [43035] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42126,9 +42328,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1214), 1, + ACTIONS(1192), 1, anon_sym_RBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42144,524 +42346,617 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42937] = 17, + [43093] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(746), 1, + ACTIONS(760), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42995] = 17, + [43151] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(748), 1, + ACTIONS(762), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43053] = 17, + [43209] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(818), 1, + ACTIONS(788), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43111] = 17, + [43267] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(790), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1216), 1, - anon_sym_COLON, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43169] = 4, + [43325] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1218), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - ACTIONS(552), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, + ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(554), 16, - sym__call_open_gap, + ACTIONS(820), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_STAR, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [43201] = 17, + [43383] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(792), 1, + ACTIONS(750), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [43441] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(1194), 1, + anon_sym_opaque, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(839), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(758), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [43495] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(996), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1196), 1, + sym__statement_break, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43259] = 17, + [43553] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(752), 1, + ACTIONS(736), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43317] = 17, + [43611] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, ACTIONS(738), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43375] = 14, + [43669] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1198), 1, + sym_identifier, + ACTIONS(1201), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1204), 1, + anon_sym_RBRACE, + ACTIONS(1206), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1212), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1221), 1, sym_float, - ACTIONS(1152), 1, - sym_identifier, - ACTIONS(1220), 1, - anon_sym_RBRACE, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1507), 1, + STATE(1470), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1215), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1218), 2, anon_sym_true, anon_sym_false, - STATE(538), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - ACTIONS(1058), 4, + STATE(598), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1209), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [43427] = 17, + [43721] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(754), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1224), 1, + anon_sym_RBRACE, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43485] = 17, + [43779] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(782), 1, + ACTIONS(792), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43543] = 17, + [43837] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(756), 1, + ACTIONS(794), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43601] = 17, + [43895] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(758), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1226), 1, + anon_sym_COMMA, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43659] = 17, + [43953] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42684,9 +42979,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1222), 1, - anon_sym_RBRACK, - STATE(1564), 1, + ACTIONS(1228), 1, + anon_sym_RBRACE, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42702,89 +42997,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43717] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(760), 1, - sym__statement_break, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43775] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(762), 1, - sym__statement_break, - ACTIONS(988), 1, - anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, - anon_sym_QMARK, - ACTIONS(1000), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, - anon_sym_AMP_AMP, - ACTIONS(1008), 1, - anon_sym_SLASH, - ACTIONS(1010), 1, - anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, - sym__call_type_arguments, - ACTIONS(992), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(996), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1006), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1004), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [43833] = 17, + [44011] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42807,9 +43020,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1224), 1, + ACTIONS(1230), 1, anon_sym_COMMA, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42825,7 +43038,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43891] = 17, + [44069] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42848,9 +43061,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1226), 1, + ACTIONS(1232), 1, anon_sym_RBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42866,292 +43079,212 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43949] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(1228), 1, - anon_sym_opaque, - STATE(226), 1, - aux_sym_doc_comment_repeat1, - STATE(828), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(749), 8, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym__module_declaration, - sym_signature_declaration, - [44003] = 17, + [44127] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1230), 1, - anon_sym_COMMA, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [44061] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, + ACTIONS(744), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1232), 1, - anon_sym_RBRACE, - STATE(1564), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44119] = 17, + [44185] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(764), 1, + ACTIONS(746), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44177] = 17, + [44243] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(766), 1, + ACTIONS(748), 1, sym__statement_break, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44235] = 17, + [44301] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(768), 1, - sym__statement_break, - ACTIONS(988), 1, + ACTIONS(432), 1, anon_sym_DOT, - ACTIONS(990), 1, + ACTIONS(434), 1, anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(442), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(444), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(446), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(452), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(454), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, + ACTIONS(456), 1, anon_sym_LBRACK2, - ACTIONS(1014), 1, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, sym__call_open_gap, - STATE(1362), 1, + ACTIONS(1234), 1, + anon_sym_RBRACK, + STATE(1574), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(438), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(440), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(448), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44293] = 17, + [44359] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(458), 1, anon_sym_LT2, - ACTIONS(988), 1, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(990), 1, - anon_sym_LBRACE, - ACTIONS(998), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(1000), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(1002), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(1008), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(1010), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(1012), 1, - anon_sym_LBRACK2, - ACTIONS(1014), 1, - sym__call_open_gap, - ACTIONS(1234), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1023), 1, sym__statement_break, - STATE(1362), 1, + STATE(1718), 1, sym__call_type_arguments, - ACTIONS(992), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(996), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1006), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1004), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44351] = 3, + [44417] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1238), 3, @@ -43177,7 +43310,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [44380] = 16, + [44446] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1242), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1240), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44475] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43198,9 +43357,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1240), 1, + ACTIONS(1244), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43216,82 +43375,79 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44435] = 13, + [44530] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1599), 1, + STATE(1470), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(582), 2, + STATE(545), 2, sym_select_arm, aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [44484] = 16, + [44579] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1564), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1128), 1, + sym_identifier, + STATE(1282), 1, + sym_qualified_path, + STATE(1470), 1, + sym_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [44539] = 16, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + STATE(552), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [44628] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43312,9 +43468,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1242), 1, + ACTIONS(1246), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43330,50 +43486,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44594] = 13, - ACTIONS(298), 1, + [44683] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1052), 1, - anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - ACTIONS(1152), 1, + ACTIONS(1250), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1248), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, sym_identifier, - STATE(1332), 1, - sym_qualified_path, - STATE(1599), 1, - sym_pattern, - ACTIONS(1062), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - STATE(543), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [44643] = 3, + [44712] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1246), 3, + ACTIONS(1254), 3, anon_sym_RBRACE, anon_sym_BANG, sym__doc_comment_line, - ACTIONS(1244), 18, + ACTIONS(1252), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43392,7 +43538,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [44672] = 16, + [44741] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43413,9 +43559,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1248), 1, + ACTIONS(1256), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43431,47 +43577,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44727] = 13, + [44796] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - STATE(1599), 1, + STATE(1470), 1, sym_pattern, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(572), 2, + STATE(575), 2, sym_select_arm, aux_sym_select_expression_repeat1, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [44776] = 16, + [44845] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1260), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1258), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44874] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, ACTIONS(442), 1, anon_sym_QMARK, ACTIONS(444), 1, @@ -43488,9 +43662,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1250), 1, - anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43506,22 +43678,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44831] = 8, + [44929] = 8, ACTIONS(3), 1, sym_line_comment, ACTIONS(839), 1, anon_sym_COLON_COLON, - ACTIONS(984), 1, + ACTIONS(981), 1, anon_sym_LT, - ACTIONS(986), 1, + ACTIONS(983), 1, anon_sym_LBRACK, - ACTIONS(1252), 1, + ACTIONS(1262), 1, anon_sym_LBRACE, - ACTIONS(1256), 1, + ACTIONS(1266), 1, anon_sym_LPAREN, STATE(397), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1254), 15, + ACTIONS(1264), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43537,59 +43709,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [44870] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1260), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1258), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [44899] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1264), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1262), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [44928] = 16, + [44968] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43610,9 +43730,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1266), 1, + ACTIONS(1268), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43628,33 +43748,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44983] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1270), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1268), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [45012] = 16, + [45023] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43675,9 +43769,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT2, ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1272), 1, + ACTIONS(1270), 1, anon_sym_LBRACE, - STATE(1564), 1, + STATE(1574), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43693,222 +43787,195 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [45067] = 13, + [45078] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, - anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - ACTIONS(1152), 1, - sym_identifier, - ACTIONS(1274), 1, - anon_sym_DOT_DOT_DOT, - STATE(1274), 1, - sym_pattern, - STATE(1332), 1, - sym_qualified_path, - ACTIONS(1062), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [45115] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + anon_sym_LT2, + ACTIONS(460), 1, + sym__call_open_gap, + ACTIONS(1272), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, - anon_sym_LPAREN, - ACTIONS(1060), 1, - anon_sym_LBRACK, - ACTIONS(1066), 1, - sym_float, - ACTIONS(1152), 1, - sym_identifier, - ACTIONS(1276), 1, - anon_sym_DOT_DOT_DOT, - STATE(1274), 1, - sym_pattern, - STATE(1332), 1, - sym_qualified_path, - ACTIONS(1062), 2, + STATE(1574), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1058), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1112), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [45163] = 13, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [45133] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - ACTIONS(1278), 1, - anon_sym_RBRACK, - STATE(1175), 1, - sym_pattern, - STATE(1332), 1, + ACTIONS(1274), 1, + anon_sym_DOT_DOT_DOT, + STATE(1282), 1, sym_qualified_path, - ACTIONS(1062), 2, + STATE(1351), 1, + sym_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45211] = 12, + [45181] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - STATE(1331), 1, + ACTIONS(1276), 1, + anon_sym_RBRACK, + STATE(1209), 1, sym_pattern, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45256] = 12, + [45229] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - STATE(1274), 1, - sym_pattern, - STATE(1332), 1, + ACTIONS(1278), 1, + anon_sym_DOT_DOT_DOT, + STATE(1282), 1, sym_qualified_path, - ACTIONS(1062), 2, + STATE(1351), 1, + sym_pattern, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45301] = 12, + [45277] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1052), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, - ACTIONS(1056), 1, + ACTIONS(1064), 1, anon_sym_LPAREN, - ACTIONS(1060), 1, + ACTIONS(1068), 1, anon_sym_LBRACK, - ACTIONS(1066), 1, + ACTIONS(1074), 1, sym_float, - ACTIONS(1152), 1, + ACTIONS(1128), 1, sym_identifier, - STATE(1183), 1, + STATE(1244), 1, sym_pattern, - STATE(1332), 1, + STATE(1282), 1, sym_qualified_path, - ACTIONS(1062), 2, + ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1064), 2, + ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - ACTIONS(1058), 4, + ACTIONS(1066), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1112), 4, + STATE(1076), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45346] = 6, + [45322] = 6, ACTIONS(3), 1, sym_line_comment, ACTIONS(839), 1, anon_sym_COLON_COLON, - ACTIONS(1252), 1, + ACTIONS(1262), 1, anon_sym_LBRACE, - ACTIONS(1256), 1, + ACTIONS(1266), 1, anon_sym_LPAREN, STATE(397), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1254), 15, + ACTIONS(1264), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43924,18 +43991,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45379] = 6, + [45355] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(984), 1, + ACTIONS(981), 1, anon_sym_LT, - ACTIONS(986), 1, + ACTIONS(983), 1, anon_sym_LBRACK, - ACTIONS(1252), 1, + ACTIONS(1262), 1, anon_sym_LBRACE, - ACTIONS(1256), 1, + ACTIONS(1266), 1, anon_sym_LPAREN, - ACTIONS(1254), 15, + ACTIONS(1264), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -43951,7 +44018,73 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45412] = 14, + [45388] = 12, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1060), 1, + anon_sym_LBRACE, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1128), 1, + sym_identifier, + STATE(1282), 1, + sym_qualified_path, + STATE(1351), 1, + sym_pattern, + ACTIONS(1070), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45433] = 12, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1060), 1, + anon_sym_LBRACE, + ACTIONS(1064), 1, + anon_sym_LPAREN, + ACTIONS(1068), 1, + anon_sym_LBRACK, + ACTIONS(1074), 1, + sym_float, + ACTIONS(1128), 1, + sym_identifier, + STATE(1282), 1, + sym_qualified_path, + STATE(1296), 1, + sym_pattern, + ACTIONS(1070), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1072), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1066), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1076), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, + [45478] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -43972,54 +44105,54 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(642), 2, + STATE(641), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45460] = 14, + [45526] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1292), 1, - anon_sym_RBRACE, - ACTIONS(1294), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(1282), 1, anon_sym_let, - ACTIONS(1297), 1, + ACTIONS(1284), 1, anon_sym_fn, - ACTIONS(1300), 1, + ACTIONS(1286), 1, anon_sym_type, - ACTIONS(1303), 1, - sym_static_stage, - ACTIONS(1306), 1, - anon_sym_effect, - ACTIONS(1309), 1, + ACTIONS(1288), 1, anon_sym_module, - ACTIONS(1312), 1, + ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1315), 1, - sym__doc_comment_line, - STATE(226), 1, + ACTIONS(1292), 1, + anon_sym_RBRACE, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(636), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45508] = 14, + [45574] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44038,22 +44171,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1318), 1, + ACTIONS(1294), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(636), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45556] = 14, + [45622] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44072,22 +44205,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1320), 1, + ACTIONS(1296), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(637), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45604] = 14, + [45670] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44106,22 +44239,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1322), 1, + ACTIONS(1298), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(636), 2, + STATE(638), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45652] = 14, + [45718] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44140,22 +44273,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1324), 1, + ACTIONS(1300), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, STATE(636), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45700] = 14, + [45766] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44174,56 +44307,56 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(1290), 1, anon_sym_opaque, - ACTIONS(1326), 1, + ACTIONS(1302), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(639), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45748] = 14, + [45814] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1304), 1, + anon_sym_RBRACE, + ACTIONS(1306), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1309), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1312), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1315), 1, + sym_static_stage, + ACTIONS(1318), 1, + anon_sym_effect, + ACTIONS(1321), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1324), 1, anon_sym_opaque, - ACTIONS(1328), 1, - anon_sym_RBRACE, - STATE(226), 1, + ACTIONS(1327), 1, + sym__doc_comment_line, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(636), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45796] = 14, + [45862] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44244,27 +44377,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, ACTIONS(1330), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1345), 1, + STATE(1369), 1, sym_doc_comment, - STATE(640), 2, + STATE(637), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(930), 5, + STATE(847), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45844] = 4, + [45910] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1252), 1, + ACTIONS(1262), 1, anon_sym_LBRACE, - ACTIONS(1256), 1, + ACTIONS(1266), 1, anon_sym_LPAREN, - ACTIONS(1254), 15, + ACTIONS(1264), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44280,12 +44413,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45871] = 4, + [45937] = 4, ACTIONS(3), 1, sym_line_comment, ACTIONS(1334), 1, anon_sym_PIPE, - STATE(645), 1, + STATE(646), 1, aux_sym_union_type_repeat1, ACTIONS(1332), 14, anon_sym_RBRACE, @@ -44302,14 +44435,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45897] = 4, + [45963] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1339), 1, + ACTIONS(1334), 1, anon_sym_PIPE, STATE(647), 1, aux_sym_union_type_repeat1, - ACTIONS(1337), 14, + ACTIONS(1336), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44324,14 +44457,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45923] = 4, + [45989] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1339), 1, + ACTIONS(1340), 1, anon_sym_PIPE, - STATE(645), 1, + STATE(647), 1, aux_sym_union_type_repeat1, - ACTIONS(1341), 14, + ACTIONS(1338), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44346,7 +44479,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45949] = 2, + [46015] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1343), 15, @@ -44365,10 +44498,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45970] = 2, + [46036] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(977), 1, + anon_sym_EQ, + ACTIONS(1345), 1, + anon_sym_COLON_COLON, + ACTIONS(1347), 1, + anon_sym_LT, + ACTIONS(1349), 1, + anon_sym_LBRACK, + STATE(652), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(979), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46067] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1332), 15, + ACTIONS(1338), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44384,14 +44541,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45991] = 4, + [46088] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(419), 1, + anon_sym_EQ, + ACTIONS(1351), 1, + anon_sym_COLON_COLON, + STATE(651), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(421), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46115] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(426), 1, + anon_sym_EQ, + ACTIONS(1345), 1, + anon_sym_COLON_COLON, + STATE(651), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(428), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46142] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1347), 1, + ACTIONS(1356), 1, anon_sym_where, - STATE(732), 1, + STATE(690), 1, sym_type_validation, - ACTIONS(1345), 13, + ACTIONS(1354), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44405,20 +44606,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46016] = 4, + [46167] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1347), 1, - anon_sym_where, - STATE(697), 1, - sym_type_validation, - ACTIONS(1349), 13, + ACTIONS(1358), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44426,14 +44625,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46041] = 4, + [46188] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1347), 1, + ACTIONS(1356), 1, anon_sym_where, - STATE(716), 1, + STATE(727), 1, sym_type_validation, - ACTIONS(1351), 13, + ACTIONS(1360), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44447,62 +44646,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46066] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(423), 1, - anon_sym_EQ, - ACTIONS(1353), 1, - anon_sym_COLON_COLON, - STATE(653), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(425), 12, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46093] = 5, - ACTIONS(298), 1, + [46213] = 4, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(419), 1, - anon_sym_EQ, ACTIONS(1356), 1, - anon_sym_COLON_COLON, - STATE(653), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(421), 12, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46120] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1358), 15, + STATE(732), 1, + sym_type_validation, + ACTIONS(1362), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44510,14 +44667,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46141] = 4, + [46238] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1347), 1, + ACTIONS(1356), 1, anon_sym_where, - STATE(708), 1, + STATE(716), 1, sym_type_validation, - ACTIONS(1360), 13, + ACTIONS(1364), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44531,31 +44688,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46166] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(980), 1, - anon_sym_EQ, - ACTIONS(1356), 1, - anon_sym_COLON_COLON, - ACTIONS(1362), 1, - anon_sym_LT, - ACTIONS(1364), 1, - anon_sym_LBRACK, - STATE(654), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(982), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46197] = 2, + [46263] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1366), 14, @@ -44573,35 +44706,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46217] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1368), 1, - sym_identifier, - ACTIONS(1370), 1, - anon_sym_LBRACE, - ACTIONS(1372), 1, - anon_sym_fn, - ACTIONS(1374), 1, - anon_sym_LPAREN, - STATE(954), 1, - sym_qualified_path, - STATE(1109), 1, - sym_variant, - STATE(1251), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(1312), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [46251] = 2, + [46283] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1376), 14, + ACTIONS(1368), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44616,10 +44724,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46271] = 2, + [46303] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1378), 14, + ACTIONS(1370), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44634,54 +44742,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46291] = 9, + [46323] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(1372), 1, sym_identifier, - ACTIONS(1382), 1, + ACTIONS(1374), 1, anon_sym_LBRACE, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(634), 1, + STATE(632), 1, sym_qualified_path, - STATE(646), 1, + STATE(645), 1, sym_variant, - STATE(651), 3, + STATE(653), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(660), 5, + STATE(659), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46325] = 3, + [46357] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1390), 1, + ACTIONS(1382), 1, anon_sym_DASH_GT, - ACTIONS(1388), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [46347] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1392), 14, + ACTIONS(1380), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44693,13 +44784,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46367] = 2, + [46379] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1394), 14, + ACTIONS(1384), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44714,10 +44804,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46387] = 2, + [46399] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1396), 14, + ACTIONS(1386), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44732,12 +44822,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46407] = 3, + [46419] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1400), 1, + ACTIONS(1390), 1, anon_sym_DASH_GT, - ACTIONS(1398), 13, + ACTIONS(1388), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44751,10 +44841,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46429] = 2, + [46441] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1402), 14, + ACTIONS(1392), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44769,35 +44859,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46449] = 9, + [46461] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(1394), 1, sym_identifier, - ACTIONS(1382), 1, + ACTIONS(1396), 1, anon_sym_LBRACE, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - STATE(634), 1, + STATE(942), 1, sym_qualified_path, - STATE(646), 1, + STATE(1072), 1, sym_variant, - STATE(652), 3, + STATE(1127), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(660), 5, + STATE(1274), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46483] = 2, + [46495] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1372), 1, + sym_identifier, + ACTIONS(1374), 1, + anon_sym_LBRACE, + ACTIONS(1376), 1, + anon_sym_fn, + ACTIONS(1378), 1, + anon_sym_LPAREN, + STATE(632), 1, + sym_qualified_path, + STATE(645), 1, + sym_variant, + STATE(657), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(659), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46529] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1404), 14, + ACTIONS(1402), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44812,12 +44927,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46503] = 3, + [46549] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1408), 1, + ACTIONS(1406), 1, anon_sym_DASH_GT, - ACTIONS(1406), 13, + ACTIONS(1404), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44831,7 +44946,25 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46525] = 2, + [46571] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1408), 14, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym__doc_comment_line, + [46591] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1410), 14, @@ -44849,7 +44982,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46545] = 2, + [46611] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1412), 14, @@ -44867,7 +45000,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46565] = 3, + [46631] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1416), 1, @@ -44886,32 +45019,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46587] = 9, + [46653] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(1372), 1, sym_identifier, - ACTIONS(1382), 1, + ACTIONS(1374), 1, anon_sym_LBRACE, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(634), 1, + STATE(632), 1, sym_qualified_path, - STATE(646), 1, + STATE(645), 1, sym_variant, - STATE(650), 3, + STATE(656), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(660), 5, + STATE(659), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46621] = 2, + [46687] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1418), 14, @@ -44929,7 +45062,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46641] = 2, + [46707] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1420), 14, @@ -44947,7 +45080,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46661] = 2, + [46727] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1422), 14, @@ -44965,7 +45098,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46681] = 2, + [46747] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1424), 14, @@ -44983,7 +45116,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46701] = 2, + [46767] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1426), 14, @@ -45001,32 +45134,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46721] = 9, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1368), 1, - sym_identifier, - ACTIONS(1370), 1, - anon_sym_LBRACE, - ACTIONS(1372), 1, - anon_sym_fn, - ACTIONS(1374), 1, - anon_sym_LPAREN, - STATE(954), 1, - sym_qualified_path, - STATE(1109), 1, - sym_variant, - STATE(1222), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(1312), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [46755] = 2, + [46787] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1428), 14, @@ -45044,7 +45152,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46775] = 2, + [46807] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1430), 14, @@ -45062,7 +45170,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46795] = 2, + [46827] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1432), 14, @@ -45080,101 +45188,126 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46815] = 3, + [46847] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(423), 1, - anon_sym_EQ, - ACTIONS(425), 13, - anon_sym_COLON_COLON, + ACTIONS(1394), 1, + sym_identifier, + ACTIONS(1396), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46837] = 9, + ACTIONS(1398), 1, + anon_sym_fn, + ACTIONS(1400), 1, + anon_sym_LPAREN, + STATE(942), 1, + sym_qualified_path, + STATE(1072), 1, + sym_variant, + STATE(1206), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(1274), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46881] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1368), 1, + ACTIONS(1394), 1, sym_identifier, - ACTIONS(1370), 1, + ACTIONS(1396), 1, anon_sym_LBRACE, - ACTIONS(1372), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - STATE(954), 1, + STATE(942), 1, sym_qualified_path, - STATE(1109), 1, + STATE(1072), 1, sym_variant, - STATE(1134), 3, + STATE(1212), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1312), 5, + STATE(1274), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46871] = 9, + [46915] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(419), 1, + anon_sym_EQ, + ACTIONS(421), 13, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [46937] = 9, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1372), 1, sym_identifier, - ACTIONS(1382), 1, + ACTIONS(1374), 1, anon_sym_LBRACE, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(634), 1, + STATE(632), 1, sym_qualified_path, - STATE(646), 1, + STATE(645), 1, sym_variant, - STATE(656), 3, + STATE(655), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(660), 5, + STATE(659), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46905] = 9, + [46971] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1368), 1, + ACTIONS(1394), 1, sym_identifier, - ACTIONS(1370), 1, + ACTIONS(1396), 1, anon_sym_LBRACE, - ACTIONS(1372), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - STATE(954), 1, + STATE(942), 1, sym_qualified_path, - STATE(1109), 1, + STATE(1072), 1, sym_variant, - STATE(1210), 3, + STATE(1142), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1312), 5, + STATE(1274), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46939] = 2, + [47005] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1434), 13, @@ -45191,7 +45324,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46958] = 2, + [47024] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1436), 13, @@ -45208,27 +45341,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46977] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(980), 1, - anon_sym_EQ, - ACTIONS(1362), 1, - anon_sym_LT, - ACTIONS(1364), 1, - anon_sym_LBRACK, - ACTIONS(982), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [47002] = 2, + [47043] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1438), 13, @@ -45245,7 +45358,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47021] = 2, + [47062] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1440), 13, @@ -45262,7 +45375,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47040] = 2, + [47081] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1442), 13, @@ -45279,7 +45392,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47059] = 2, + [47100] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1444), 13, @@ -45296,7 +45409,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47078] = 2, + [47119] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1446), 13, @@ -45313,7 +45426,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47097] = 2, + [47138] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1448), 13, @@ -45330,7 +45443,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47116] = 2, + [47157] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1450), 13, @@ -45347,7 +45460,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47135] = 2, + [47176] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1452), 13, @@ -45364,7 +45477,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47154] = 2, + [47195] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1454), 13, @@ -45381,7 +45494,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47173] = 2, + [47214] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1456), 13, @@ -45398,7 +45511,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47192] = 2, + [47233] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1458), 13, @@ -45415,7 +45528,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47211] = 2, + [47252] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1460), 13, @@ -45432,7 +45545,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47230] = 2, + [47271] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1462), 13, @@ -45449,7 +45562,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47249] = 2, + [47290] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1464), 13, @@ -45466,7 +45579,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47268] = 2, + [47309] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1466), 13, @@ -45483,58 +45596,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47287] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1468), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [47306] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1470), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [47325] = 2, + [47328] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1472), 13, + ACTIONS(1468), 1, + anon_sym_COLON_COLON, + ACTIONS(1472), 1, + anon_sym_LT2, + STATE(774), 1, + aux_sym_qualified_path_repeat1, + STATE(892), 1, + sym_type_arguments, + ACTIONS(1470), 9, anon_sym_RBRACE, anon_sym_let, - anon_sym_mut, anon_sym_fn, - anon_sym_extern, anon_sym_type, sym_static_stage, anon_sym_effect, - anon_sym_state, anon_sym_module, - anon_sym_export, - anon_sym_signature, + anon_sym_opaque, sym__doc_comment_line, - [47344] = 2, + [47355] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1474), 13, @@ -45551,7 +45634,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47363] = 2, + [47374] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1476), 13, @@ -45568,7 +45651,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47382] = 2, + [47393] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1478), 13, @@ -45585,7 +45668,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47401] = 2, + [47412] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1480), 13, @@ -45602,7 +45685,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47420] = 2, + [47431] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1482), 13, @@ -45619,7 +45702,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47439] = 2, + [47450] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1484), 13, @@ -45636,7 +45719,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47458] = 2, + [47469] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1486), 13, @@ -45653,7 +45736,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47477] = 2, + [47488] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1488), 13, @@ -45670,7 +45753,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47496] = 2, + [47507] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1490), 13, @@ -45687,7 +45770,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47515] = 2, + [47526] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1492), 13, @@ -45704,7 +45787,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47534] = 2, + [47545] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1494), 13, @@ -45721,7 +45804,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47553] = 2, + [47564] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1496), 13, @@ -45738,7 +45821,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47572] = 2, + [47583] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1498), 13, @@ -45755,7 +45838,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47591] = 2, + [47602] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1500), 13, @@ -45772,7 +45855,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47610] = 2, + [47621] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1502), 13, @@ -45789,7 +45872,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47629] = 2, + [47640] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1504), 13, @@ -45806,7 +45889,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47648] = 2, + [47659] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1506), 13, @@ -45823,7 +45906,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47667] = 2, + [47678] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1508), 13, @@ -45840,7 +45923,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47686] = 2, + [47697] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1510), 13, @@ -45857,7 +45940,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47705] = 2, + [47716] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1512), 13, @@ -45874,7 +45957,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47724] = 2, + [47735] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1514), 13, @@ -45891,7 +45974,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47743] = 2, + [47754] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1516), 13, @@ -45908,7 +45991,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47762] = 2, + [47773] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1518), 13, @@ -45925,7 +46008,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47781] = 2, + [47792] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1520), 13, @@ -45942,7 +46025,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47800] = 2, + [47811] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1522), 13, @@ -45959,7 +46042,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47819] = 2, + [47830] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1524), 13, @@ -45976,7 +46059,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47838] = 2, + [47849] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1526), 13, @@ -45993,7 +46076,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47857] = 2, + [47868] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1528), 13, @@ -46010,7 +46093,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47876] = 2, + [47887] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1530), 13, @@ -46027,7 +46110,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47895] = 2, + [47906] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1532), 13, @@ -46044,7 +46127,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47914] = 2, + [47925] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1534), 13, @@ -46061,7 +46144,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47933] = 2, + [47944] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1536), 13, @@ -46078,7 +46161,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47952] = 2, + [47963] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1538), 13, @@ -46095,7 +46178,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47971] = 2, + [47982] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1540), 13, @@ -46112,7 +46195,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47990] = 2, + [48001] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1542), 13, @@ -46129,7 +46212,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48009] = 2, + [48020] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1544), 13, @@ -46146,7 +46229,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48028] = 2, + [48039] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1546), 13, @@ -46163,7 +46246,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48047] = 2, + [48058] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1548), 13, @@ -46180,7 +46263,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48066] = 2, + [48077] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1550), 13, @@ -46197,7 +46280,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48085] = 2, + [48096] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1552), 13, @@ -46214,7 +46297,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48104] = 2, + [48115] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1554), 13, @@ -46231,7 +46314,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48123] = 2, + [48134] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1556), 13, @@ -46248,31 +46331,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48142] = 6, + [48153] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1558), 1, - anon_sym_COLON_COLON, - ACTIONS(1562), 1, - anon_sym_LT2, - STATE(773), 1, - aux_sym_qualified_path_repeat1, - STATE(880), 1, - sym_type_arguments, - ACTIONS(1560), 9, + ACTIONS(1558), 13, anon_sym_RBRACE, anon_sym_let, + anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_state, anon_sym_module, - anon_sym_opaque, + anon_sym_export, + anon_sym_signature, sym__doc_comment_line, - [48169] = 2, + [48172] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(568), 13, + ACTIONS(1560), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46286,10 +46365,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48188] = 2, + [48191] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(600), 13, + ACTIONS(1562), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46303,7 +46382,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48207] = 2, + [48210] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1564), 13, @@ -46320,7 +46399,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48226] = 2, + [48229] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48248] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(554), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [48267] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1566), 13, @@ -46337,7 +46450,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48245] = 2, + [48286] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(977), 1, + anon_sym_EQ, + ACTIONS(1347), 1, + anon_sym_LT, + ACTIONS(1349), 1, + anon_sym_LBRACK, + ACTIONS(979), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [48311] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1568), 13, @@ -46354,7 +46487,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48264] = 2, + [48330] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1570), 13, @@ -46371,7 +46504,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48283] = 2, + [48349] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1572), 13, @@ -46388,7 +46521,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48302] = 10, + [48368] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46399,39 +46532,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(1580), 1, sym_replayable, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48336] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(423), 1, - anon_sym_COLON, - ACTIONS(1582), 1, - anon_sym_COLON_COLON, - STATE(761), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(425), 9, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_LPAREN, - anon_sym_RBRACK, - anon_sym_PLUS, - anon_sym_LT2, - sym_identifier, - [48360] = 10, + [48402] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46440,22 +46554,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1585), 1, + ACTIONS(1582), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(777), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48394] = 10, + [48436] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46464,22 +46578,60 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1587), 1, + ACTIONS(1584), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48428] = 10, + [48470] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1588), 1, + anon_sym_DASH_GT, + ACTIONS(1590), 1, + anon_sym_BANG, + STATE(849), 1, + sym_effect_set, + ACTIONS(1586), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48494] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(419), 1, + anon_sym_COLON, + ACTIONS(1592), 1, + anon_sym_COLON_COLON, + STATE(764), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(421), 9, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_LPAREN, + anon_sym_RBRACK, + anon_sym_PLUS, + anon_sym_LT2, + sym_identifier, + [48518] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46488,41 +46640,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1589), 1, + ACTIONS(1595), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48462] = 5, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1593), 1, - anon_sym_DASH_GT, - ACTIONS(1595), 1, - anon_sym_BANG, - STATE(879), 1, - sym_effect_set, - ACTIONS(1591), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48486] = 10, + [48552] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46533,62 +46666,85 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1597), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(775), 2, + STATE(771), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48520] = 4, - ACTIONS(3), 1, + [48586] = 8, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(839), 1, - anon_sym_COLON_COLON, - STATE(779), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1599), 10, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_PLUS, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48542] = 10, + ACTIONS(1603), 1, + anon_sym_LPAREN, + STATE(756), 1, + sym_qualified_path, + STATE(1515), 1, + sym__call_type_list, + ACTIONS(1605), 2, + anon_sym_in, + anon_sym_out, + STATE(1221), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [48616] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1601), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(1574), 1, sym_identifier, - ACTIONS(1604), 1, - anon_sym_RBRACE, - ACTIONS(1609), 1, + ACTIONS(1580), 1, sym_replayable, - ACTIONS(1612), 1, - sym__doc_comment_line, - STATE(226), 1, + ACTIONS(1607), 1, + anon_sym_RBRACE, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1606), 3, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48576] = 10, + [48650] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1590), 1, + anon_sym_BANG, + ACTIONS(1611), 1, + anon_sym_DASH_GT, + STATE(869), 1, + sym_effect_set, + ACTIONS(1609), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48674] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46597,22 +46753,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1615), 1, + ACTIONS(1613), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(763), 2, + STATE(778), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48610] = 10, + [48708] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46621,22 +46777,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1617), 1, + ACTIONS(1615), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(764), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48644] = 10, + [48742] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46645,22 +46801,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1619), 1, + ACTIONS(1617), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(787), 2, + STATE(762), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48678] = 10, + [48776] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46669,29 +46825,29 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1621), 1, + ACTIONS(1619), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(761), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48712] = 4, + [48810] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1558), 1, + ACTIONS(1468), 1, anon_sym_COLON_COLON, - STATE(774), 1, + STATE(775), 1, aux_sym_qualified_path_repeat1, - ACTIONS(421), 10, + ACTIONS(428), 10, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46702,14 +46858,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48734] = 4, + [48832] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1623), 1, + ACTIONS(1621), 1, anon_sym_COLON_COLON, - STATE(774), 1, + STATE(775), 1, aux_sym_qualified_path_repeat1, - ACTIONS(425), 10, + ACTIONS(421), 10, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46720,7 +46876,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48756] = 10, + [48854] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46729,22 +46885,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1626), 1, + ACTIONS(1624), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(797), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48790] = 10, + [48888] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46753,22 +46909,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1628), 1, + ACTIONS(1626), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(760), 2, + STATE(781), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48824] = 10, + [48922] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46777,22 +46933,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1630), 1, + ACTIONS(1628), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48858] = 10, + [48956] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46801,40 +46957,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1632), 1, + ACTIONS(1630), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(782), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48892] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(839), 1, - anon_sym_COLON_COLON, - STATE(396), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1634), 10, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_PLUS, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48914] = 10, + [48990] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46843,13 +46981,13 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1636), 1, + ACTIONS(1632), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, STATE(768), 2, sym_operation_declaration, @@ -46858,7 +46996,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_abort, anon_sym_once, anon_sym_many, - [48948] = 10, + [49024] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46867,22 +47005,41 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1638), 1, + ACTIONS(1634), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(784), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48982] = 10, + [49058] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1590), 1, + anon_sym_BANG, + ACTIONS(1638), 1, + anon_sym_DASH_GT, + STATE(891), 1, + sym_effect_set, + ACTIONS(1636), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49082] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46893,20 +47050,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1640), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(787), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49016] = 10, + [49116] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46917,20 +47074,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1642), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(788), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49050] = 10, + [49150] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46941,20 +47098,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1644), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(779), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49084] = 10, + [49184] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46965,20 +47122,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1646), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(791), 2, + STATE(789), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49118] = 10, + [49218] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -46989,20 +47146,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1648), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(797), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49152] = 10, + [49252] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47013,20 +47170,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1650), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(792), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49186] = 10, + [49286] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47037,27 +47194,27 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1652), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49220] = 5, + [49320] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1595), 1, + ACTIONS(1590), 1, anon_sym_BANG, ACTIONS(1656), 1, anon_sym_DASH_GT, - STATE(882), 1, + STATE(840), 1, sym_effect_set, ACTIONS(1654), 9, anon_sym_RBRACE, @@ -47069,7 +47226,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49244] = 10, + [49344] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47080,20 +47237,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1658), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(793), 2, + STATE(794), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49278] = 10, + [49378] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47104,20 +47261,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1660), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49312] = 10, + [49412] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47128,20 +47285,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1662), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(795), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49346] = 10, + [49446] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47152,20 +47309,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1664), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49380] = 10, + [49480] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47176,20 +47333,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1666), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(796), 2, + STATE(760), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49414] = 10, + [49514] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47200,20 +47357,20 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1668), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49448] = 10, + [49548] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47224,44 +47381,80 @@ static const uint16_t ts_small_parse_table[] = { sym_replayable, ACTIONS(1670), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49482] = 10, + [49582] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(1574), 1, - sym_identifier, - ACTIONS(1580), 1, - sym_replayable, ACTIONS(1672), 1, + sym_identifier, + ACTIONS(1675), 1, anon_sym_RBRACE, - STATE(226), 1, + ACTIONS(1680), 1, + sym_replayable, + ACTIONS(1683), 1, + sym__doc_comment_line, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(768), 2, + STATE(798), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1677), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49516] = 10, + [49616] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + STATE(800), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1686), 10, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49638] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + STATE(396), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1688), 10, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49660] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47270,41 +47463,22 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1674), 1, + ACTIONS(1690), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(772), 2, + STATE(765), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49550] = 5, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1595), 1, - anon_sym_BANG, - ACTIONS(1678), 1, - anon_sym_DASH_GT, - STATE(932), 1, - sym_effect_set, - ACTIONS(1676), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49574] = 10, + [49694] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -47313,31 +47487,29 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, ACTIONS(1580), 1, sym_replayable, - ACTIONS(1680), 1, + ACTIONS(1692), 1, anon_sym_RBRACE, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(952), 1, + STATE(968), 1, sym_multiplicity, - STATE(972), 1, + STATE(991), 1, sym_doc_comment, - STATE(780), 2, + STATE(784), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49608] = 5, + [49728] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1595), 1, + ACTIONS(1590), 1, anon_sym_BANG, - ACTIONS(1684), 1, - anon_sym_DASH_GT, - STATE(898), 1, + STATE(909), 1, sym_effect_set, - ACTIONS(1682), 9, + ACTIONS(1694), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47347,14 +47519,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49632] = 4, + [49749] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1595), 1, + ACTIONS(1590), 1, anon_sym_BANG, - STATE(934), 1, + STATE(893), 1, sym_effect_set, - ACTIONS(1686), 9, + ACTIONS(1696), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47364,46 +47536,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49653] = 3, - ACTIONS(298), 1, + [49770] = 4, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1244), 1, + ACTIONS(1700), 1, anon_sym_EQ, - ACTIONS(1246), 10, - anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LT, + ACTIONS(1698), 9, anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [49672] = 3, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49791] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1268), 1, - anon_sym_EQ, - ACTIONS(1270), 10, + ACTIONS(419), 1, + anon_sym_COLON, + ACTIONS(421), 10, + anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, + anon_sym_EQ, + anon_sym_LPAREN, anon_sym_RBRACK, - anon_sym_EQ_GT, - [49691] = 4, + anon_sym_PLUS, + anon_sym_LT2, + sym_identifier, + [49810] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1690), 1, - anon_sym_EQ, - ACTIONS(1692), 1, - anon_sym_LT, - ACTIONS(1688), 9, + ACTIONS(1472), 1, + anon_sym_LT2, + STATE(892), 1, + sym_type_arguments, + ACTIONS(1470), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47413,24 +47586,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49712] = 4, + [49831] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1696), 1, - anon_sym_EQ, - ACTIONS(1698), 1, - anon_sym_LT, - ACTIONS(1694), 9, + ACTIONS(421), 11, + anon_sym_COLON_COLON, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, anon_sym_type, sym_static_stage, anon_sym_effect, + anon_sym_LT2, anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49733] = 3, + [49848] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(1258), 1, @@ -47446,28 +47617,74 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [49752] = 3, - ACTIONS(298), 1, + [49867] = 4, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1262), 1, - anon_sym_EQ, - ACTIONS(1264), 10, - anon_sym_LBRACE, + ACTIONS(1590), 1, + anon_sym_BANG, + STATE(881), 1, + sym_effect_set, + ACTIONS(1704), 9, anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49888] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, + anon_sym_fn, + ACTIONS(1603), 1, + anon_sym_LPAREN, + ACTIONS(1706), 1, anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [49771] = 3, + STATE(756), 1, + sym_qualified_path, + STATE(1370), 1, + sym_type_list, + STATE(1091), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [49917] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1236), 1, + ACTIONS(1710), 1, + anon_sym_fn, + ACTIONS(1712), 1, + anon_sym_extern, + ACTIONS(1714), 1, + anon_sym_type, + ACTIONS(1716), 1, + sym_static_stage, + ACTIONS(1718), 1, + anon_sym_effect, + ACTIONS(1720), 1, + anon_sym_state, + ACTIONS(1722), 1, + anon_sym_module, + ACTIONS(1724), 1, + anon_sym_export, + ACTIONS(1726), 1, + anon_sym_signature, + ACTIONS(1708), 2, + anon_sym_let, + anon_sym_mut, + [49952] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1252), 1, anon_sym_EQ, - ACTIONS(1238), 10, + ACTIONS(1254), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -47478,45 +47695,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [49790] = 2, + [49971] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(425), 11, - anon_sym_COLON_COLON, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_LT2, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49807] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(423), 1, - anon_sym_COLON, - ACTIONS(425), 10, - anon_sym_DOT, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_COMMA, + ACTIONS(1730), 1, anon_sym_EQ, - anon_sym_LPAREN, - anon_sym_RBRACK, - anon_sym_PLUS, - anon_sym_LT2, - sym_identifier, - [49826] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1595), 1, - anon_sym_BANG, - STATE(843), 1, - sym_effect_set, - ACTIONS(1700), 9, + ACTIONS(1732), 1, + anon_sym_LT, + ACTIONS(1728), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47526,14 +47712,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49847] = 4, + [49992] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1595), 1, + ACTIONS(1590), 1, anon_sym_BANG, - STATE(903), 1, + STATE(906), 1, sym_effect_set, - ACTIONS(1702), 9, + ACTIONS(1734), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47543,236 +47729,221 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49868] = 8, + [50013] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1710), 1, - anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1377), 1, - sym_type_list, - STATE(1105), 5, + ACTIONS(1736), 2, + anon_sym_in, + anon_sym_out, + STATE(1313), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49897] = 8, + [50040] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1248), 1, + anon_sym_EQ, + ACTIONS(1250), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [50059] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1712), 1, + ACTIONS(1738), 1, anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1442), 1, + STATE(1602), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49926] = 8, + [50088] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1236), 1, + anon_sym_EQ, + ACTIONS(1238), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [50107] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1714), 1, + ACTIONS(1740), 1, anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1592), 1, + STATE(1618), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49955] = 8, + [50136] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1716), 1, + ACTIONS(1742), 1, anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1608), 1, + STATE(1667), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49984] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1562), 1, - anon_sym_LT2, - STATE(880), 1, - sym_type_arguments, - ACTIONS(1560), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50005] = 8, + [50165] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1718), 1, + ACTIONS(1744), 1, anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1657), 1, + STATE(1673), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50034] = 11, + [50194] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1722), 1, - anon_sym_fn, - ACTIONS(1724), 1, - anon_sym_extern, - ACTIONS(1726), 1, - anon_sym_type, - ACTIONS(1728), 1, - sym_static_stage, - ACTIONS(1730), 1, - anon_sym_effect, - ACTIONS(1732), 1, - anon_sym_state, - ACTIONS(1734), 1, - anon_sym_module, - ACTIONS(1736), 1, - anon_sym_export, - ACTIONS(1738), 1, - anon_sym_signature, - ACTIONS(1720), 2, - anon_sym_let, - anon_sym_mut, - [50069] = 8, + ACTIONS(1240), 1, + anon_sym_EQ, + ACTIONS(1242), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [50213] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1740), 1, + ACTIONS(1746), 1, anon_sym_RPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1663), 1, + STATE(1440), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50098] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1595), 1, - anon_sym_BANG, - STATE(894), 1, - sym_effect_set, - ACTIONS(1742), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50119] = 7, + [50242] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1575), 1, + STATE(1597), 1, sym_positional_payload, - STATE(1177), 5, + STATE(1208), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50145] = 7, - ACTIONS(298), 1, + [50268] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1750), 1, + anon_sym_EQ, + ACTIONS(1748), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1708), 1, - anon_sym_LPAREN, - STATE(691), 1, - sym_qualified_path, - STATE(1503), 1, - sym_type_list, - STATE(1105), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50171] = 4, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50286] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - STATE(761), 1, + STATE(764), 1, aux_sym_qualified_path_repeat1, - ACTIONS(421), 8, + ACTIONS(428), 8, anon_sym_DOT, anon_sym_LBRACE, anon_sym_COMMA, @@ -47781,235 +47952,183 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_LT2, sym_identifier, - [50191] = 7, + [50306] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1748), 1, + STATE(1756), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50217] = 11, + [50332] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(931), 1, - anon_sym_COMMA, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(1746), 1, - sym_identifier, - ACTIONS(1748), 1, - anon_sym_LBRACE, - ACTIONS(1750), 1, - anon_sym_RBRACE, ACTIONS(1752), 1, - anon_sym_COLON, - ACTIONS(1754), 1, - anon_sym_LPAREN, - ACTIONS(1756), 1, - anon_sym_EQ_GT, - STATE(825), 1, - aux_sym_qualified_path_repeat1, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, - [50251] = 10, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1722), 1, - anon_sym_fn, - ACTIONS(1724), 1, - anon_sym_extern, - ACTIONS(1726), 1, - anon_sym_type, - ACTIONS(1728), 1, - sym_static_stage, - ACTIONS(1730), 1, - anon_sym_effect, - ACTIONS(1732), 1, - anon_sym_state, - ACTIONS(1734), 1, - anon_sym_module, - ACTIONS(1738), 1, - anon_sym_signature, - ACTIONS(1720), 2, - anon_sym_let, - anon_sym_mut, - [50283] = 8, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1744), 1, anon_sym_COLON_COLON, - ACTIONS(1746), 1, + ACTIONS(1754), 1, sym_identifier, - ACTIONS(1748), 1, + ACTIONS(1756), 1, anon_sym_LBRACE, - ACTIONS(1752), 1, + ACTIONS(1760), 1, anon_sym_COLON, - ACTIONS(1754), 1, + ACTIONS(1762), 1, anon_sym_LPAREN, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1756), 4, + ACTIONS(1758), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [50311] = 7, + [50360] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1405), 1, + STATE(1445), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50337] = 7, + [50386] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(886), 1, + anon_sym_COMMA, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1754), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1756), 1, + anon_sym_LBRACE, + ACTIONS(1758), 1, + anon_sym_EQ_GT, + ACTIONS(1760), 1, + anon_sym_COLON, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1764), 1, + anon_sym_RBRACE, + STATE(827), 1, + aux_sym_qualified_path_repeat1, + STATE(1218), 1, + aux_sym_field_pattern_repeat1, + [50420] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1444), 1, + STATE(1415), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50363] = 7, + [50446] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1422), 1, + STATE(1432), 1, sym_positional_payload, - STATE(1177), 5, + STATE(1208), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50389] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1760), 1, - anon_sym_PLUS, - ACTIONS(1758), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50407] = 7, + [50472] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1766), 1, + anon_sym_LBRACE, + STATE(756), 1, sym_qualified_path, - STATE(1426), 1, - sym_type_list, - STATE(1105), 5, + STATE(1107), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50433] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1764), 1, - anon_sym_EQ, - ACTIONS(1762), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50451] = 7, + [50498] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1766), 1, - anon_sym_LBRACE, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1099), 5, + STATE(1399), 1, + sym_type_list, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50477] = 7, + [50524] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1523), 1, + STATE(1533), 1, sym_type_list, - STATE(1105), 5, + STATE(1091), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50503] = 3, + [50550] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1770), 1, @@ -48024,60 +48143,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50521] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, - anon_sym_fn, - ACTIONS(1708), 1, - anon_sym_LPAREN, - STATE(691), 1, - sym_qualified_path, - STATE(1406), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50544] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, - anon_sym_fn, - ACTIONS(1708), 1, - anon_sym_LPAREN, - STATE(691), 1, - sym_qualified_path, - STATE(1519), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50567] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, - anon_sym_fn, - ACTIONS(1708), 1, - anon_sym_LPAREN, - STATE(691), 1, - sym_qualified_path, - STATE(1029), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50590] = 2, - ACTIONS(3), 1, + [50568] = 3, + ACTIONS(3), 1, sym_line_comment, + ACTIONS(1774), 1, + anon_sym_PLUS, ACTIONS(1772), 9, anon_sym_RBRACE, anon_sym_let, @@ -48088,10 +48158,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50605] = 2, + [50586] = 10, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1710), 1, + anon_sym_fn, + ACTIONS(1712), 1, + anon_sym_extern, + ACTIONS(1714), 1, + anon_sym_type, + ACTIONS(1716), 1, + sym_static_stage, + ACTIONS(1718), 1, + anon_sym_effect, + ACTIONS(1720), 1, + anon_sym_state, + ACTIONS(1722), 1, + anon_sym_module, + ACTIONS(1726), 1, + anon_sym_signature, + ACTIONS(1708), 2, + anon_sym_let, + anon_sym_mut, + [50618] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1774), 9, + ACTIONS(1776), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48101,382 +48193,359 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50620] = 6, + [50633] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - STATE(691), 1, - sym_qualified_path, - STATE(1272), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50643] = 8, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1776), 1, - anon_sym_COLON_COLON, ACTIONS(1778), 1, - anon_sym_LBRACE, - ACTIONS(1780), 1, - anon_sym_LT, - ACTIONS(1782), 1, - anon_sym_LPAREN, - ACTIONS(1784), 1, - anon_sym_LBRACK, - STATE(866), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1254), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [50670] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1372), 1, - anon_sym_fn, - ACTIONS(1374), 1, - anon_sym_LPAREN, - ACTIONS(1786), 1, sym_identifier, - STATE(1106), 1, + STATE(1095), 1, sym_qualified_path, - STATE(1750), 5, + STATE(1306), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50693] = 6, + [50656] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, - sym_identifier, - STATE(1106), 1, + STATE(756), 1, sym_qualified_path, - STATE(1268), 5, + STATE(1057), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50716] = 6, + [50679] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(943), 5, + STATE(1151), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50739] = 6, + [50702] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(944), 5, + STATE(948), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50762] = 6, + [50725] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(945), 5, + STATE(617), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50785] = 6, + [50748] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(622), 5, + STATE(947), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50808] = 6, + [50771] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1782), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50786] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(946), 5, + STATE(810), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50831] = 6, + [50809] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1784), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50824] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(948), 5, + STATE(1053), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50854] = 6, + [50847] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1786), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50862] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(950), 5, + STATE(611), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50877] = 6, + [50885] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1215), 5, + STATE(1016), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50900] = 6, + [50908] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1778), 1, sym_identifier, - STATE(503), 1, + STATE(1095), 1, sym_qualified_path, - STATE(625), 5, + STATE(1530), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50923] = 6, + [50931] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1463), 5, + STATE(1446), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50946] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1790), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50961] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1792), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50976] = 6, + [50954] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(881), 5, + STATE(1231), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50999] = 6, + [50977] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1778), 1, sym_identifier, - STATE(503), 1, + STATE(1095), 1, sym_qualified_path, - STATE(617), 5, + STATE(1583), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51022] = 6, + [51000] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(803), 5, + STATE(612), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51045] = 6, + [51023] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1778), 1, sym_identifier, - STATE(503), 1, + STATE(1095), 1, sym_qualified_path, - STATE(966), 5, + STATE(1319), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51068] = 6, + [51046] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(942), 5, + STATE(998), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51091] = 6, + [51069] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(994), 5, + STATE(954), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51114] = 4, + [51092] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1776), 1, + ACTIONS(1788), 1, anon_sym_COLON_COLON, - STATE(867), 1, + STATE(864), 1, aux_sym_qualified_path_repeat1, - ACTIONS(421), 7, + ACTIONS(428), 7, sym__statement_break, anon_sym_LBRACE, anon_sym_LT, @@ -48484,14 +48553,31 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_where, anon_sym_LBRACK, - [51133] = 4, + [51111] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1376), 1, + anon_sym_fn, + ACTIONS(1378), 1, + anon_sym_LPAREN, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, + sym_qualified_path, + STATE(958), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51134] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1794), 1, + ACTIONS(1790), 1, anon_sym_COLON_COLON, - STATE(867), 1, + STATE(864), 1, aux_sym_qualified_path_repeat1, - ACTIONS(425), 7, + ACTIONS(421), 7, sym__statement_break, anon_sym_LBRACE, anon_sym_LT, @@ -48499,194 +48585,237 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_where, anon_sym_LBRACK, - [51152] = 6, + [51153] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(1106), 1, + STATE(518), 1, sym_qualified_path, - STATE(1636), 5, + STATE(959), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51175] = 6, + [51176] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(1106), 1, + STATE(518), 1, sym_qualified_path, - STATE(1295), 5, + STATE(964), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51198] = 6, + [51199] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1020), 5, + STATE(1284), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51221] = 6, + [51222] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1696), 5, + STATE(804), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51244] = 6, + [51245] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1793), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51260] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(939), 5, + STATE(883), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51267] = 6, + [51283] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + STATE(756), 1, + sym_qualified_path, + STATE(1275), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51306] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1795), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51321] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1599), 1, sym_identifier, - STATE(503), 1, + ACTIONS(1601), 1, + anon_sym_fn, + ACTIONS(1603), 1, + anon_sym_LPAREN, + STATE(756), 1, sym_qualified_path, - STATE(964), 5, + STATE(1004), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51290] = 6, + [51344] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(807), 5, + STATE(1729), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51313] = 6, + [51367] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1778), 1, sym_identifier, - STATE(503), 1, + STATE(1095), 1, sym_qualified_path, - STATE(940), 5, + STATE(1314), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51336] = 6, + [51390] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(941), 5, + STATE(966), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51359] = 6, + [51413] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(953), 5, + STATE(1474), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51382] = 6, + [51436] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(813), 5, + STATE(943), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51405] = 2, + [51459] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1797), 9, @@ -48699,7 +48828,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51420] = 2, + [51474] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1398), 1, + anon_sym_fn, + ACTIONS(1400), 1, + anon_sym_LPAREN, + ACTIONS(1778), 1, + sym_identifier, + STATE(1095), 1, + sym_qualified_path, + STATE(1458), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51497] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1799), 9, @@ -48712,7 +48858,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51435] = 2, + [51512] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, + anon_sym_fn, + ACTIONS(1603), 1, + anon_sym_LPAREN, + STATE(756), 1, + sym_qualified_path, + STATE(1262), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51535] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1801), 9, @@ -48725,7 +48888,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51450] = 2, + [51550] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1803), 9, @@ -48738,135 +48901,187 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51465] = 6, + [51565] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(957), 5, + STATE(897), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51488] = 6, + [51588] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1805), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51603] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(963), 5, + STATE(1026), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51511] = 6, + [51626] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(1106), 1, + STATE(518), 1, sym_qualified_path, - STATE(1735), 5, + STATE(699), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51534] = 6, + [51649] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(704), 5, + STATE(815), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51557] = 6, + [51672] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(968), 5, + STATE(962), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51580] = 6, + [51695] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1807), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51710] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1809), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51725] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1811), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51740] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(1106), 1, + STATE(518), 1, sym_qualified_path, - STATE(1353), 5, + STATE(715), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51603] = 6, + [51763] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(715), 5, + STATE(912), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51626] = 6, + [51786] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, STATE(721), 5, sym__type, @@ -48874,10 +49089,10 @@ static const uint16_t ts_small_parse_table[] = { sym_generic_type, sym_array_type, sym_type_identifier, - [51649] = 2, + [51809] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1805), 9, + ACTIONS(1813), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48887,33 +49102,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51664] = 6, + [51824] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1032), 5, + STATE(970), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51687] = 6, + [51847] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, STATE(731), 5, sym__type, @@ -48921,151 +49136,112 @@ static const uint16_t ts_small_parse_table[] = { sym_generic_type, sym_array_type, sym_type_identifier, - [51710] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1807), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51725] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1809), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51740] = 6, + [51870] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1505), 5, + STATE(971), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51763] = 6, + [51893] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(802), 5, + STATE(946), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51786] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1811), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51801] = 6, + [51916] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(908), 5, + STATE(1521), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51824] = 6, + [51939] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1017), 5, + STATE(1013), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51847] = 6, + [51962] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1242), 5, + STATE(960), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51870] = 6, + [51985] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1129), 5, + STATE(803), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51893] = 2, + [52008] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1813), 9, + ACTIONS(1815), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49075,78 +49251,117 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51908] = 6, + [52023] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1027), 5, + STATE(914), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51931] = 6, + [52046] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1817), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52061] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1819), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52076] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, - sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - STATE(691), 1, + ACTIONS(1780), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1366), 5, + STATE(952), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51954] = 6, + [52099] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(858), 5, + STATE(944), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51977] = 6, + [52122] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1821), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52137] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1386), 5, + STATE(1376), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52000] = 2, + [52160] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1815), 9, + ACTIONS(1823), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49156,50 +49371,67 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [52015] = 6, + [52175] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + STATE(756), 1, + sym_qualified_path, + STATE(1396), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52198] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1376), 1, + anon_sym_fn, + ACTIONS(1378), 1, + anon_sym_LPAREN, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(859), 5, + STATE(851), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52038] = 6, + [52221] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1407), 5, + STATE(823), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52061] = 6, + [52244] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, STATE(1416), 5, sym__type, @@ -49207,448 +49439,409 @@ static const uint16_t ts_small_parse_table[] = { sym_generic_type, sym_array_type, sym_type_identifier, - [52084] = 6, + [52267] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(998), 5, + STATE(1417), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52107] = 6, + [52290] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, - sym_identifier, - STATE(503), 1, + STATE(756), 1, sym_qualified_path, - STATE(935), 5, + STATE(1426), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52130] = 6, + [52313] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1054), 5, + STATE(1012), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52153] = 6, + [52336] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1788), 1, + anon_sym_COLON_COLON, + ACTIONS(1825), 1, + anon_sym_LBRACE, + ACTIONS(1827), 1, + anon_sym_LT, + ACTIONS(1829), 1, + anon_sym_LPAREN, + ACTIONS(1831), 1, + anon_sym_LBRACK, + STATE(862), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1264), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [52363] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1038), 5, + STATE(1015), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52176] = 6, + [52386] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(997), 5, + STATE(1017), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52199] = 6, + [52409] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1004), 5, + STATE(1668), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52222] = 6, + [52432] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1009), 5, + STATE(1020), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52245] = 6, + [52455] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1010), 5, + STATE(1022), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52268] = 6, + [52478] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1012), 5, + STATE(1023), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52291] = 6, + [52501] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1052), 5, + STATE(1024), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52314] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1817), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52329] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1819), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52344] = 6, + [52524] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1518), 5, + STATE(1025), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52367] = 6, + [52547] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(804), 5, + STATE(1258), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52390] = 6, + [52570] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1374), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - ACTIONS(1786), 1, - sym_identifier, - STATE(1106), 1, + STATE(756), 1, sym_qualified_path, - STATE(1447), 5, + STATE(1528), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52413] = 6, + [52593] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1524), 5, + STATE(817), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52436] = 6, + [52616] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1525), 5, + STATE(1534), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52459] = 6, + [52639] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1448), 5, + STATE(1535), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52482] = 2, - ACTIONS(3), 1, + [52662] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1821), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1599), 1, + sym_identifier, + ACTIONS(1601), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52497] = 6, + ACTIONS(1603), 1, + anon_sym_LPAREN, + STATE(756), 1, + sym_qualified_path, + STATE(1049), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52685] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1398), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1400), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1778), 1, sym_identifier, - STATE(503), 1, + STATE(1095), 1, sym_qualified_path, - STATE(822), 5, + STATE(1498), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52520] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1823), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52535] = 6, + [52708] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1704), 1, + ACTIONS(1599), 1, sym_identifier, - ACTIONS(1706), 1, + ACTIONS(1601), 1, anon_sym_fn, - ACTIONS(1708), 1, + ACTIONS(1603), 1, anon_sym_LPAREN, - STATE(691), 1, + STATE(756), 1, sym_qualified_path, - STATE(1022), 5, + STATE(819), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52558] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1825), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52573] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1827), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52588] = 6, + [52731] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, + ACTIONS(1376), 1, anon_sym_fn, - ACTIONS(1386), 1, + ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1788), 1, + ACTIONS(1780), 1, sym_identifier, - STATE(503), 1, + STATE(518), 1, sym_qualified_path, - STATE(812), 5, + STATE(963), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52611] = 6, + [52754] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(421), 8, + sym__statement_break, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + anon_sym_LBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_LBRACK, + [52768] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1833), 1, anon_sym_LT2, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1108), 1, + STATE(1085), 1, sym_type_arguments, - ACTIONS(1560), 4, + ACTIONS(1470), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, anon_sym_RBRACK, - [52633] = 2, + [52790] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(425), 8, - sym__statement_break, - anon_sym_COLON_COLON, + ACTIONS(1825), 1, anon_sym_LBRACE, + ACTIONS(1827), 1, anon_sym_LT, + ACTIONS(1829), 1, anon_sym_LPAREN, + ACTIONS(1831), 1, + anon_sym_LBRACK, + ACTIONS(1264), 3, + sym__statement_break, anon_sym_PIPE, anon_sym_where, - anon_sym_LBRACK, - [52647] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1833), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1831), 5, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - sym_identifier, - [52662] = 3, + [52811] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1837), 2, @@ -49660,7 +49853,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [52677] = 3, + [52826] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1841), 2, @@ -49672,7 +49865,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [52692] = 3, + [52841] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1788), 1, + anon_sym_COLON_COLON, + ACTIONS(1825), 1, + anon_sym_LBRACE, + ACTIONS(1829), 1, + anon_sym_LPAREN, + STATE(862), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1264), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [52862] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1845), 2, @@ -49684,7 +49892,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [52707] = 3, + [52877] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1849), 2, @@ -49696,7 +49904,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [52722] = 3, + [52892] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1853), 2, @@ -49708,263 +49916,214 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [52737] = 3, - ACTIONS(3), 1, + [52907] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1857), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1855), 5, + ACTIONS(1855), 1, + sym_identifier, + ACTIONS(1857), 1, + anon_sym_COLON, + ACTIONS(1859), 1, + sym_replayable, + STATE(1632), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, + [52928] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1861), 1, + sym_identifier, + ACTIONS(1863), 1, + anon_sym_COLON, + ACTIONS(1865), 1, sym_replayable, + STATE(1640), 1, + sym_multiplicity, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [52949] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1863), 1, + anon_sym_COLON, + ACTIONS(1867), 1, sym_identifier, - [52752] = 3, + ACTIONS(1869), 1, + sym_replayable, + STATE(1649), 1, + sym_multiplicity, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [52970] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1861), 2, + ACTIONS(1873), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1859), 5, + ACTIONS(1871), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52767] = 7, + [52985] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1202), 1, + STATE(1182), 1, sym_type_arguments, - STATE(1064), 2, + STATE(997), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52790] = 3, + [53008] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1867), 2, + ACTIONS(1879), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1865), 5, + ACTIONS(1877), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52805] = 6, + [53023] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1869), 1, - sym_identifier, - ACTIONS(1871), 1, - anon_sym_COLON, - ACTIONS(1873), 1, - sym_replayable, - STATE(1630), 1, - sym_multiplicity, - ACTIONS(1578), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [52826] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1877), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1875), 5, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, sym_identifier, - [52841] = 7, + STATE(827), 1, + aux_sym_qualified_path_repeat1, + STATE(1189), 1, + sym_type_arguments, + STATE(1001), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53046] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1209), 1, + STATE(1160), 1, sym_type_arguments, - STATE(1070), 2, + STATE(1034), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [52864] = 6, + [53069] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1871), 1, - anon_sym_COLON, - ACTIONS(1879), 1, - sym_identifier, ACTIONS(1881), 1, + sym_identifier, + ACTIONS(1883), 1, + anon_sym_COLON, + ACTIONS(1885), 1, sym_replayable, - STATE(1639), 1, + STATE(1695), 1, sym_multiplicity, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [52885] = 3, + [53090] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1885), 2, + ACTIONS(1889), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1883), 5, + ACTIONS(1887), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52900] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1778), 1, - anon_sym_LBRACE, - ACTIONS(1780), 1, - anon_sym_LT, - ACTIONS(1782), 1, - anon_sym_LPAREN, - ACTIONS(1784), 1, - anon_sym_LBRACK, - ACTIONS(1254), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [52921] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1776), 1, - anon_sym_COLON_COLON, - ACTIONS(1778), 1, - anon_sym_LBRACE, - ACTIONS(1782), 1, - anon_sym_LPAREN, - STATE(866), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1254), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [52942] = 6, - ACTIONS(298), 1, + [53105] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1887), 1, - sym_identifier, - ACTIONS(1889), 1, - anon_sym_COLON, - ACTIONS(1891), 1, - sym_replayable, - STATE(1609), 1, - sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1893), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1891), 5, anon_sym_abort, anon_sym_once, anon_sym_many, - [52963] = 3, + sym_replayable, + sym_identifier, + [53120] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1895), 2, + ACTIONS(1897), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1893), 5, + ACTIONS(1895), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52978] = 6, + [53135] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1897), 1, - sym_identifier, ACTIONS(1899), 1, - anon_sym_COLON, + sym_identifier, ACTIONS(1901), 1, + anon_sym_COLON, + ACTIONS(1903), 1, sym_replayable, - STATE(1620), 1, + STATE(1473), 1, sym_multiplicity, ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [52999] = 7, - ACTIONS(298), 1, + [53156] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, - sym_identifier, - STATE(825), 1, - aux_sym_qualified_path_repeat1, - STATE(1236), 1, - sym_type_arguments, - STATE(1098), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53022] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1903), 1, - sym_identifier, - ACTIONS(1905), 1, - anon_sym_COLON, - ACTIONS(1907), 1, - sym_replayable, - STATE(1472), 1, - sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1907), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1905), 5, anon_sym_abort, anon_sym_once, anon_sym_many, - [53043] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, + sym_replayable, sym_identifier, - STATE(825), 1, - aux_sym_qualified_path_repeat1, - STATE(1239), 1, - sym_type_arguments, - STATE(1100), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53066] = 6, - ACTIONS(298), 1, + [53171] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1899), 1, - anon_sym_COLON, - ACTIONS(1909), 1, - sym_identifier, - ACTIONS(1911), 1, - sym_replayable, - STATE(1629), 1, - sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1911), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1909), 5, anon_sym_abort, anon_sym_once, anon_sym_many, - [53087] = 3, + sym_replayable, + sym_identifier, + [53186] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1915), 2, @@ -49976,7 +50135,23 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [53102] = 3, + [53201] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, + sym_identifier, + STATE(827), 1, + aux_sym_qualified_path_repeat1, + STATE(1228), 1, + sym_type_arguments, + STATE(1027), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53224] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1919), 2, @@ -49988,51 +50163,54 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [53117] = 7, + [53239] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1154), 1, + STATE(1232), 1, sym_type_arguments, - STATE(1114), 2, + STATE(1029), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53140] = 3, - ACTIONS(3), 1, + [53262] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1923), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1921), 5, + ACTIONS(1901), 1, + anon_sym_COLON, + ACTIONS(1921), 1, + sym_identifier, + ACTIONS(1923), 1, + sym_replayable, + STATE(1516), 1, + sym_multiplicity, + ACTIONS(1578), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, - sym_identifier, - [53155] = 7, + [53283] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1261), 1, + STATE(1220), 1, sym_type_arguments, - STATE(1077), 2, + STATE(1003), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53178] = 3, + [53306] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1927), 2, @@ -50044,76 +50222,67 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_many, sym_replayable, sym_identifier, - [53193] = 4, - ACTIONS(298), 1, + [53321] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - STATE(1108), 1, - sym_type_arguments, - ACTIONS(1560), 4, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - [53209] = 7, + ACTIONS(1931), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1929), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [53336] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(1931), 1, + ACTIONS(1935), 1, anon_sym_EQ, - ACTIONS(1933), 1, + ACTIONS(1937), 1, anon_sym_DASH_GT, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, - STATE(1126), 1, - sym_effect_set, - STATE(1556), 1, + STATE(757), 1, sym_block, - [53231] = 3, + STATE(1192), 1, + sym_effect_set, + [53358] = 7, ACTIONS(298), 1, sym_line_comment, + ACTIONS(1933), 1, + anon_sym_LBRACE, ACTIONS(1939), 1, - anon_sym_COLON, - ACTIONS(1937), 5, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - sym_identifier, - [53245] = 5, - ACTIONS(298), 1, - sym_line_comment, + anon_sym_BANG, ACTIONS(1941), 1, - sym_identifier, + anon_sym_EQ, ACTIONS(1943), 1, - sym_replayable, - STATE(962), 1, - sym_multiplicity, - ACTIONS(1578), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [53263] = 7, + anon_sym_DASH_GT, + STATE(692), 1, + sym_block, + STATE(1259), 1, + sym_effect_set, + [53380] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1945), 1, anon_sym_EQ, ACTIONS(1947), 1, anon_sym_DASH_GT, - STATE(1253), 1, - sym_effect_set, - STATE(1553), 1, + STATE(738), 1, sym_block, - [53285] = 7, + STATE(1261), 1, + sym_effect_set, + [53402] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, @@ -50121,29 +50290,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1953), 1, anon_sym_DASH_GT, - STATE(689), 1, - sym_block, - STATE(1125), 1, + STATE(1219), 1, sym_effect_set, - [53307] = 7, + STATE(1419), 1, + sym_block, + [53424] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, ACTIONS(1955), 1, anon_sym_EQ, ACTIONS(1957), 1, anon_sym_DASH_GT, - STATE(707), 1, + STATE(710), 1, sym_block, - STATE(1150), 1, + STATE(1222), 1, sym_effect_set, - [53329] = 7, + [53446] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, @@ -50151,14 +50320,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1961), 1, anon_sym_DASH_GT, - STATE(738), 1, - sym_block, - STATE(1168), 1, + STATE(1147), 1, sym_effect_set, - [53351] = 7, + STATE(1631), 1, + sym_block, + [53468] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1833), 1, + anon_sym_LT2, + STATE(1085), 1, + sym_type_arguments, + ACTIONS(1470), 4, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + [53484] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, @@ -50166,73 +50347,79 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1965), 1, anon_sym_DASH_GT, - STATE(712), 1, - sym_block, - STATE(1153), 1, + STATE(1256), 1, sym_effect_set, - [53373] = 7, + STATE(1444), 1, + sym_block, + [53506] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1803), 6, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1935), 1, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + sym_identifier, + [53518] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1939), 1, anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, ACTIONS(1967), 1, anon_sym_EQ, ACTIONS(1969), 1, anon_sym_DASH_GT, - STATE(1188), 1, + STATE(1197), 1, sym_effect_set, - STATE(1378), 1, + STATE(1565), 1, sym_block, - [53395] = 7, + [53540] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, ACTIONS(1971), 1, anon_sym_EQ, ACTIONS(1973), 1, anon_sym_DASH_GT, - STATE(756), 1, + STATE(718), 1, sym_block, - STATE(1135), 1, + STATE(1169), 1, sym_effect_set, - [53417] = 6, + [53562] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1977), 1, + anon_sym_COLON, + ACTIONS(1975), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [53576] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1776), 1, + ACTIONS(1788), 1, anon_sym_COLON_COLON, - ACTIONS(1780), 1, + ACTIONS(1827), 1, anon_sym_LT, - ACTIONS(1784), 1, + ACTIONS(1831), 1, anon_sym_LBRACK, - STATE(866), 1, + STATE(862), 1, aux_sym_qualified_path_repeat1, - ACTIONS(982), 2, + ACTIONS(979), 2, sym__statement_break, anon_sym_where, - [53437] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1975), 1, - anon_sym_EQ, - ACTIONS(1977), 1, - anon_sym_DASH_GT, - STATE(1184), 1, - sym_effect_set, - STATE(1717), 1, - sym_block, - [53459] = 7, + [53596] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, @@ -50240,1055 +50427,1101 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1981), 1, anon_sym_DASH_GT, - STATE(695), 1, - sym_block, - STATE(1139), 1, + STATE(1141), 1, sym_effect_set, - [53481] = 7, + STATE(1433), 1, + sym_block, + [53618] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1983), 1, anon_sym_EQ, ACTIONS(1985), 1, anon_sym_DASH_GT, - STATE(1128), 1, - sym_effect_set, - STATE(1532), 1, + STATE(759), 1, sym_block, - [53503] = 7, + STATE(1249), 1, + sym_effect_set, + [53640] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, ACTIONS(1987), 1, anon_sym_EQ, ACTIONS(1989), 1, anon_sym_DASH_GT, - STATE(1156), 1, + STATE(1235), 1, sym_effect_set, - STATE(1653), 1, + STATE(1566), 1, sym_block, - [53525] = 7, + [53662] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, ACTIONS(1991), 1, anon_sym_EQ, ACTIONS(1993), 1, anon_sym_DASH_GT, - STATE(725), 1, + STATE(703), 1, sym_block, - STATE(1160), 1, + STATE(1216), 1, sym_effect_set, - [53547] = 2, + [53684] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1809), 6, - anon_sym_DOT, + ACTIONS(1933), 1, anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - sym_identifier, - [53559] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, ACTIONS(1995), 1, anon_sym_EQ, ACTIONS(1997), 1, anon_sym_DASH_GT, STATE(728), 1, sym_block, - STATE(1161), 1, + STATE(1251), 1, sym_effect_set, - [53581] = 7, + [53706] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, ACTIONS(1999), 1, anon_sym_EQ, ACTIONS(2001), 1, anon_sym_DASH_GT, - STATE(1234), 1, + STATE(1237), 1, sym_effect_set, - STATE(1561), 1, + STATE(1518), 1, sym_block, - [53603] = 7, + [53728] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, ACTIONS(2003), 1, - anon_sym_EQ, + sym_identifier, ACTIONS(2005), 1, - anon_sym_DASH_GT, - STATE(1232), 1, - sym_effect_set, - STATE(1384), 1, - sym_block, - [53625] = 5, + sym_replayable, + STATE(951), 1, + sym_multiplicity, + ACTIONS(1578), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [53746] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(2007), 1, - anon_sym_COLON, - STATE(1037), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1599), 2, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(1949), 1, anon_sym_LBRACE, - anon_sym_PLUS, - [53642] = 5, + ACTIONS(2007), 1, + anon_sym_EQ, + ACTIONS(2009), 1, + anon_sym_DASH_GT, + STATE(1253), 1, + sym_effect_set, + STATE(1651), 1, + sym_block, + [53768] = 5, ACTIONS(298), 1, sym_line_comment, ACTIONS(2011), 1, - anon_sym_RPAREN, - STATE(1117), 1, - sym_parameter, - STATE(1427), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, sym_identifier, - [53659] = 5, + STATE(1191), 1, + sym_type_parameter, + STATE(1702), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [53785] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1365), 1, + STATE(1386), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [53676] = 5, + [53802] = 5, ACTIONS(298), 1, sym_line_comment, ACTIONS(2017), 1, anon_sym_RPAREN, - STATE(1117), 1, + STATE(1108), 1, sym_parameter, - STATE(1584), 1, + STATE(1469), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [53693] = 6, + [53819] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(2019), 1, - anon_sym_EQ, + ACTIONS(2011), 1, + sym_identifier, STATE(1191), 1, - sym_effect_set, - STATE(1733), 1, - sym_block, - [53712] = 5, + sym_type_parameter, + STATE(1394), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [53836] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1209), 1, - sym_type_arguments, - STATE(1070), 2, + ACTIONS(2021), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53729] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2021), 1, - anon_sym_RPAREN, - STATE(1117), 1, - sym_parameter, - STATE(1467), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, - sym_identifier, - [53746] = 6, + [53851] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, ACTIONS(2023), 1, anon_sym_EQ, - STATE(730), 1, - sym_block, - STATE(1163), 1, + STATE(1179), 1, sym_effect_set, - [53765] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2025), 1, - anon_sym_EQ, - STATE(702), 1, + STATE(1646), 1, sym_block, - STATE(1146), 1, - sym_effect_set, - [53784] = 5, + [53870] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1498), 1, + STATE(1478), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [53801] = 5, + [53887] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2027), 1, + ACTIONS(2025), 1, anon_sym_RPAREN, - STATE(1117), 1, + STATE(1108), 1, sym_parameter, - STATE(1703), 1, + STATE(1480), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [53818] = 5, + [53904] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1399), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2027), 2, anon_sym_in, - anon_sym_out, - [53835] = 5, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53919] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1617), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2029), 2, anon_sym_in, - anon_sym_out, - [53852] = 5, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53934] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2029), 1, - anon_sym_RPAREN, - STATE(1117), 1, - sym_parameter, - STATE(1610), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, + ACTIONS(2019), 1, sym_identifier, - [53869] = 6, + ACTIONS(2031), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53949] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2031), 1, + ACTIONS(2033), 1, anon_sym_EQ, - STATE(735), 1, - sym_block, - STATE(1165), 1, + STATE(1123), 1, sym_effect_set, - [53888] = 4, + STATE(1658), 1, + sym_block, + [53968] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1778), 1, - anon_sym_LBRACE, - ACTIONS(1782), 1, - anon_sym_LPAREN, - ACTIONS(1254), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [53903] = 5, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, + sym_type_parameter, + STATE(1463), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [53985] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1195), 1, + ACTIONS(2035), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54000] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, sym_type_parameter, - STATE(1502), 1, + STATE(1484), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [53920] = 5, + [54017] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1478), 1, + STATE(1491), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [53937] = 5, + [54034] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2033), 1, + ACTIONS(1825), 1, + anon_sym_LBRACE, + ACTIONS(1829), 1, + anon_sym_LPAREN, + ACTIONS(1264), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [54049] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, + sym_type_parameter, + STATE(1483), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [54066] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2037), 1, anon_sym_RPAREN, - STATE(1117), 1, + STATE(1108), 1, sym_parameter, - STATE(1619), 1, + STATE(1476), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [53954] = 6, + [54083] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2035), 1, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2039), 1, anon_sym_EQ, - STATE(742), 1, + STATE(697), 1, sym_block, - STATE(1169), 1, + STATE(1207), 1, sym_effect_set, - [53973] = 6, + [54102] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2037), 1, + ACTIONS(2041), 1, anon_sym_EQ, - STATE(743), 1, - sym_block, - STATE(1170), 1, + STATE(1193), 1, sym_effect_set, - [53992] = 5, + STATE(1479), 1, + sym_block, + [54121] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2039), 1, + ACTIONS(2043), 1, anon_sym_RPAREN, - STATE(1117), 1, + STATE(1108), 1, sym_parameter, - STATE(1625), 1, + STATE(1487), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [54009] = 6, + [54138] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2045), 1, + anon_sym_EQ, + STATE(713), 1, + sym_block, + STATE(1226), 1, + sym_effect_set, + [54157] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2041), 1, + ACTIONS(2047), 1, anon_sym_EQ, - STATE(747), 1, + STATE(1205), 1, + sym_effect_set, + STATE(1490), 1, sym_block, - STATE(1171), 1, + [54176] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2049), 1, + anon_sym_EQ, + STATE(719), 1, + sym_block, + STATE(1234), 1, sym_effect_set, - [54028] = 5, + [54195] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, - sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1438), 1, - sym_type_parameter_list, + ACTIONS(2051), 1, + anon_sym_PIPE, + STATE(1108), 1, + sym_parameter, + STATE(1564), 1, + sym_parameter_list, ACTIONS(2015), 2, - anon_sym_in, - anon_sym_out, - [54045] = 5, + anon_sym__, + sym_identifier, + [54212] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, - sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1470), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, - anon_sym_in, - anon_sym_out, - [54062] = 5, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(2053), 1, + anon_sym_DOT, + STATE(827), 1, + aux_sym_qualified_path_repeat1, + STATE(1608), 1, + sym_type_arguments, + [54231] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, - sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1622), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, - anon_sym_in, - anon_sym_out, - [54079] = 6, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2055), 1, + anon_sym_EQ, + STATE(730), 1, + sym_block, + STATE(1255), 1, + sym_effect_set, + [54250] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2043), 1, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, sym_identifier, - ACTIONS(2045), 1, - sym_string, - STATE(1066), 1, - sym_import_target, - STATE(1068), 1, - sym_namespace_name, - STATE(1668), 1, - sym_legacy_import_path, - [54098] = 6, + STATE(1220), 1, + sym_type_arguments, + STATE(1003), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54267] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, - ACTIONS(2047), 1, + ACTIONS(2057), 1, anon_sym_EQ, - STATE(1259), 1, - sym_effect_set, - STATE(1414), 1, + STATE(735), 1, sym_block, - [54117] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2049), 1, - anon_sym_PIPE, - STATE(1117), 1, - sym_parameter, - STATE(1634), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, - sym_identifier, - [54134] = 5, + STATE(1257), 1, + sym_effect_set, + [54286] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2051), 1, - anon_sym_RPAREN, - STATE(1117), 1, - sym_parameter, - STATE(1646), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, - sym_identifier, - [54151] = 6, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2059), 1, + anon_sym_EQ, + STATE(742), 1, + sym_block, + STATE(1264), 1, + sym_effect_set, + [54305] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, - ACTIONS(2053), 1, + ACTIONS(2061), 1, anon_sym_EQ, - STATE(1193), 1, - sym_effect_set, - STATE(1746), 1, + STATE(743), 1, sym_block, - [54170] = 5, + STATE(1265), 1, + sym_effect_set, + [54324] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, - sym_identifier, - STATE(1236), 1, - sym_type_arguments, - STATE(1098), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54187] = 6, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(2063), 1, + anon_sym_EQ, + STATE(747), 1, + sym_block, + STATE(1122), 1, + sym_effect_set, + [54343] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, - ACTIONS(2055), 1, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2065), 1, anon_sym_EQ, - STATE(1204), 1, + STATE(1143), 1, sym_effect_set, - STATE(1434), 1, + STATE(1713), 1, sym_block, - [54206] = 5, + [54362] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2057), 1, + ACTIONS(2019), 1, + sym_identifier, + ACTIONS(2067), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54377] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2069), 1, anon_sym_RPAREN, - STATE(1117), 1, + STATE(1108), 1, sym_parameter, - STATE(1624), 1, + STATE(1759), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [54223] = 5, + [54394] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1154), 1, - sym_type_arguments, - STATE(1114), 2, + ACTIONS(2071), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54240] = 5, + [54409] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(2019), 1, sym_identifier, - STATE(1239), 1, - sym_type_arguments, - STATE(1100), 2, + ACTIONS(2073), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54257] = 5, + [54424] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2059), 1, - anon_sym_PIPE, - STATE(1117), 1, - sym_parameter, - STATE(1413), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, + ACTIONS(2019), 1, sym_identifier, - [54274] = 6, + ACTIONS(2075), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54439] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(2061), 1, - anon_sym_EQ, - STATE(1145), 1, - sym_effect_set, - STATE(1574), 1, - sym_block, - [54293] = 6, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, + sym_type_parameter, + STATE(1591), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [54456] = 6, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, ACTIONS(859), 1, anon_sym_type, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(748), 1, + STATE(749), 1, sym_type_declaration, - STATE(1702), 1, + STATE(1743), 1, sym_doc_comment, - [54312] = 6, + [54475] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(2063), 1, - anon_sym_EQ, - STATE(1131), 1, - sym_effect_set, - STATE(1628), 1, - sym_block, - [54331] = 6, + ACTIONS(2019), 1, + sym_identifier, + ACTIONS(2077), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54490] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(2065), 1, - anon_sym_DOT, - STATE(825), 1, - aux_sym_qualified_path_repeat1, - STATE(1648), 1, - sym_type_arguments, - [54350] = 4, + ACTIONS(2079), 1, + anon_sym_PIPE, + STATE(1108), 1, + sym_parameter, + STATE(1560), 1, + sym_parameter_list, + ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [54507] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2081), 1, + anon_sym_RPAREN, + STATE(1108), 1, + sym_parameter, + STATE(1579), 1, + sym_parameter_list, + ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [54524] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2083), 1, anon_sym_DOT, - STATE(1224), 1, + STATE(1139), 1, aux_sym_legacy_import_path_repeat1, - ACTIONS(2069), 3, + ACTIONS(2085), 3, sym__statement_break, anon_sym_COLON_COLON, anon_sym_as, - [54365] = 6, + [54539] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, + sym_identifier, + STATE(1182), 1, + sym_type_arguments, + STATE(997), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54556] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(2087), 1, + anon_sym_COLON, + STATE(1058), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1686), 2, anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(2071), 1, - anon_sym_EQ, - STATE(1246), 1, - sym_effect_set, - STATE(1400), 1, - sym_block, - [54384] = 5, + anon_sym_PLUS, + [54573] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2073), 1, - anon_sym_PIPE, - STATE(1117), 1, + ACTIONS(2019), 1, + sym_identifier, + ACTIONS(2089), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54588] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2019), 1, + sym_identifier, + ACTIONS(2091), 2, + anon_sym_in, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54603] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2093), 1, + anon_sym_RPAREN, + STATE(1108), 1, sym_parameter, - STATE(1550), 1, + STATE(1594), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [54401] = 5, + [54620] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1586), 1, - sym_type_parameter_list, + STATE(1189), 1, + sym_type_arguments, + STATE(1001), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54637] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, + sym_identifier, + STATE(1160), 1, + sym_type_arguments, + STATE(1034), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54654] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2095), 1, + anon_sym_RPAREN, + STATE(1108), 1, + sym_parameter, + STATE(1620), 1, + sym_parameter_list, ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [54671] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2097), 1, + anon_sym_RPAREN, + STATE(1108), 1, + sym_parameter, + STATE(1629), 1, + sym_parameter_list, + ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [54688] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2099), 1, + sym_identifier, + ACTIONS(2102), 2, anon_sym_in, - anon_sym_out, - [54418] = 5, + anon_sym_do, + STATE(1047), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54703] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2104), 1, + anon_sym_RPAREN, + STATE(1108), 1, + sym_parameter, + STATE(1635), 1, + sym_parameter_list, + ACTIONS(2015), 2, + anon_sym__, sym_identifier, - STATE(1195), 1, + [54720] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2106), 1, + anon_sym_EQ, + STATE(1152), 1, + sym_effect_set, + STATE(1578), 1, + sym_block, + [54739] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, sym_type_parameter, - STATE(1611), 1, + STATE(1619), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54435] = 5, + [54756] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2075), 1, - anon_sym_RPAREN, - STATE(1117), 1, + ACTIONS(2108), 1, + anon_sym_PIPE, + STATE(1108), 1, sym_parameter, - STATE(1569), 1, + STATE(1644), 1, sym_parameter_list, - ACTIONS(2009), 2, + ACTIONS(2015), 2, anon_sym__, sym_identifier, - [54452] = 5, + [54773] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(2077), 1, - anon_sym_COLON, - STATE(761), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1634), 2, - anon_sym_LBRACE, - anon_sym_PLUS, - [54469] = 6, + ACTIONS(2110), 1, + anon_sym_RPAREN, + STATE(1108), 1, + sym_parameter, + STATE(1656), 1, + sym_parameter_list, + ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [54790] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1935), 1, + ACTIONS(1939), 1, anon_sym_BANG, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2079), 1, + ACTIONS(2112), 1, anon_sym_EQ, - STATE(719), 1, - sym_block, - STATE(1157), 1, + STATE(1146), 1, sym_effect_set, - [54488] = 5, + STATE(1456), 1, + sym_block, + [54809] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(1202), 1, + STATE(1228), 1, sym_type_arguments, - STATE(1064), 2, + STATE(1027), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54505] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1744), 1, - anon_sym_COLON_COLON, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(2081), 1, - anon_sym_DOT, - STATE(825), 1, - aux_sym_qualified_path_repeat1, - STATE(1725), 1, - sym_type_arguments, - [54524] = 5, + [54826] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1692), 1, + STATE(1744), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54541] = 5, + [54843] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(1875), 1, sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1485), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, - anon_sym_in, - anon_sym_out, - [54558] = 5, + STATE(1232), 1, + sym_type_arguments, + STATE(1029), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54860] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2083), 1, - anon_sym_RPAREN, - STATE(1117), 1, - sym_parameter, - STATE(1374), 1, - sym_parameter_list, - ACTIONS(2009), 2, - anon_sym__, - sym_identifier, - [54575] = 5, + ACTIONS(1939), 1, + anon_sym_BANG, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2114), 1, + anon_sym_EQ, + STATE(1167), 1, + sym_effect_set, + STATE(1593), 1, + sym_block, + [54879] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, - sym_identifier, - STATE(1195), 1, - sym_type_parameter, - STATE(1698), 1, - sym_type_parameter_list, - ACTIONS(2015), 2, - anon_sym_in, - anon_sym_out, - [54592] = 5, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(2116), 1, + anon_sym_COLON, + STATE(764), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1688), 2, + anon_sym_LBRACE, + anon_sym_PLUS, + [54896] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1699), 1, + STATE(1596), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54609] = 5, + [54913] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1701), 1, + STATE(1621), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54626] = 6, + [54930] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON_COLON, - ACTIONS(1829), 1, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(2085), 1, + ACTIONS(2118), 1, anon_sym_DOT, - STATE(825), 1, + STATE(827), 1, aux_sym_qualified_path_repeat1, - STATE(1736), 1, + STATE(1735), 1, sym_type_arguments, - [54645] = 5, + [54949] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2120), 1, sym_identifier, - STATE(1195), 1, + ACTIONS(2122), 1, + sym_string, + STATE(1082), 1, + sym_import_target, + STATE(1099), 1, + sym_namespace_name, + STATE(1660), 1, + sym_legacy_import_path, + [54968] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, sym_type_parameter, - STATE(1465), 1, + STATE(1708), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54662] = 5, + [54985] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1727), 1, + STATE(1709), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54679] = 5, + [55002] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1195), 1, + STATE(1191), 1, sym_type_parameter, - STATE(1730), 1, + STATE(1711), 1, sym_type_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54696] = 5, + [55019] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, + ACTIONS(1752), 1, + anon_sym_COLON_COLON, + ACTIONS(1833), 1, anon_sym_LT2, - ACTIONS(1863), 1, - sym_identifier, - STATE(1261), 1, + ACTIONS(2124), 1, + anon_sym_DOT, + STATE(827), 1, + aux_sym_qualified_path_repeat1, + STATE(1746), 1, sym_type_arguments, - STATE(1077), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54713] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(2087), 1, - anon_sym_EQ, - STATE(1229), 1, - sym_effect_set, - STATE(1441), 1, - sym_block, - [54732] = 6, + [55038] = 6, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, ACTIONS(859), 1, anon_sym_type, - STATE(226), 1, + STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(751), 1, + STATE(711), 1, sym_type_declaration, - STATE(1702), 1, + STATE(1743), 1, sym_doc_comment, - [54751] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1935), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2089), 1, - anon_sym_EQ, - STATE(714), 1, - sym_block, - STATE(1155), 1, - sym_effect_set, - [54770] = 4, + [55057] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2013), 1, + ACTIONS(2011), 1, sym_identifier, - STATE(1329), 1, + STATE(1191), 1, sym_type_parameter, - ACTIONS(2015), 2, + STATE(1737), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, anon_sym_in, anon_sym_out, - [54784] = 4, + [55074] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2091), 1, - anon_sym_COMMA, - STATE(1056), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2094), 2, - anon_sym_GT, - anon_sym_RPAREN, - [54798] = 4, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, + sym_type_parameter, + STATE(1740), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [55091] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2096), 1, - anon_sym_PIPE, - STATE(1060), 1, - aux_sym_union_type_repeat1, - ACTIONS(1341), 2, - sym__statement_break, - anon_sym_where, - [54812] = 4, + ACTIONS(2011), 1, + sym_identifier, + STATE(1191), 1, + sym_type_parameter, + STATE(1395), 1, + sym_type_parameter_list, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [55108] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2098), 1, + ACTIONS(2126), 4, anon_sym_COMMA, - STATE(1056), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2100), 2, - anon_sym_GT, anon_sym_RPAREN, - [54826] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2102), 1, - sym_identifier, - ACTIONS(2104), 1, + anon_sym_RBRACK, anon_sym_EQ_GT, - STATE(1133), 1, - aux_sym_handler_params_repeat1, - STATE(1544), 1, - sym_handler_params, - [54842] = 4, + [55118] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2106), 1, + ACTIONS(2128), 1, anon_sym_PIPE, - STATE(1060), 1, + STATE(1113), 1, aux_sym_union_type_repeat1, ACTIONS(1332), 2, sym__statement_break, anon_sym_where, - [54856] = 5, + [55132] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2102), 1, - sym_identifier, - ACTIONS(2109), 1, - anon_sym_EQ_GT, - STATE(1133), 1, - aux_sym_handler_params_repeat1, - STATE(1560), 1, - sym_handler_params, - [54872] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2111), 1, + ACTIONS(2130), 4, anon_sym_COMMA, - STATE(1062), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1028), 2, anon_sym_RPAREN, anon_sym_RBRACK, - [54886] = 4, + anon_sym_EQ_GT, + [55142] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2114), 1, + ACTIONS(2132), 1, sym_identifier, - ACTIONS(2116), 1, + ACTIONS(2135), 1, anon_sym_in, - STATE(1088), 2, + STATE(1074), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [54900] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2120), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54914] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2122), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54928] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2124), 1, - anon_sym_COLON_COLON, - ACTIONS(2126), 1, - anon_sym_as, - ACTIONS(2128), 1, - sym__statement_break, - STATE(1526), 1, - sym_import_tail, - [54944] = 5, + [55156] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, - sym_identifier, - ACTIONS(2132), 1, + ACTIONS(2137), 4, + anon_sym_COMMA, anon_sym_RPAREN, - STATE(1254), 1, - sym_extern_parameter, - STATE(1391), 1, - sym_extern_parameter_list, - [54960] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2134), 1, - anon_sym_COLON_COLON, - STATE(1092), 1, - aux_sym_import_target_repeat1, - ACTIONS(2137), 2, - sym__statement_break, - anon_sym_as, - [54974] = 2, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55166] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2139), 4, @@ -51296,4342 +51529,4369 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [54984] = 4, + [55176] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2141), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54998] = 4, + ACTIONS(2141), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55186] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2143), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55012] = 5, + ACTIONS(2143), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55196] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, - sym_identifier, - ACTIONS(2145), 1, + ACTIONS(2145), 4, + anon_sym_COMMA, anon_sym_RPAREN, - STATE(1254), 1, - sym_extern_parameter, - STATE(1387), 1, - sym_extern_parameter_list, - [55028] = 5, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55206] = 5, ACTIONS(298), 1, sym_line_comment, ACTIONS(2147), 1, sym_identifier, - ACTIONS(2149), 1, - anon_sym_RBRACE, - STATE(1152), 1, - sym_import_member, - STATE(1508), 1, - sym_import_member_list, - [55044] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2151), 1, - sym_identifier, - ACTIONS(2153), 1, - anon_sym_LBRACK, - STATE(818), 1, + STATE(978), 1, sym_qualified_path, - STATE(891), 1, + STATE(1194), 1, sym_effect_ref, - [55060] = 4, + STATE(1482), 1, + sym_effect_list, + [55222] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2155), 1, + ACTIONS(2149), 1, anon_sym_COLON_COLON, - STATE(1075), 1, + STATE(1115), 1, aux_sym_import_target_repeat1, - ACTIONS(2158), 2, + ACTIONS(2152), 2, sym__statement_break, anon_sym_as, - [55074] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2160), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55088] = 4, + [55236] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2162), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55102] = 3, + ACTIONS(2154), 1, + anon_sym_COLON_COLON, + ACTIONS(2156), 1, + anon_sym_as, + ACTIONS(2158), 1, + sym__statement_break, + STATE(1727), 1, + sym_import_tail, + [55252] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2166), 1, - anon_sym_COLON, - ACTIONS(2164), 3, + ACTIONS(2160), 4, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_PIPE, - [55114] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2130), 1, - sym_identifier, - ACTIONS(2168), 1, - anon_sym_RPAREN, - STATE(1254), 1, - sym_extern_parameter, - STATE(1432), 1, - sym_extern_parameter_list, - [55130] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55262] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, + ACTIONS(2147), 1, sym_identifier, - ACTIONS(2170), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55144] = 2, + STATE(978), 1, + sym_qualified_path, + STATE(1194), 1, + sym_effect_ref, + STATE(1450), 1, + sym_effect_list, + [55278] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2172), 4, + ACTIONS(1809), 4, + anon_sym_LBRACE, anon_sym_COMMA, - anon_sym_RPAREN, + anon_sym_EQ, anon_sym_RBRACK, - anon_sym_EQ_GT, - [55154] = 2, + [55288] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2162), 1, + sym_identifier, + ACTIONS(2164), 1, + anon_sym_LBRACK, + STATE(807), 1, + sym_qualified_path, + STATE(886), 1, + sym_effect_ref, + [55304] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2174), 4, + ACTIONS(2166), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55164] = 4, + [55314] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2176), 1, + ACTIONS(2168), 1, anon_sym_COMMA, - STATE(1083), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2179), 2, + STATE(1088), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1050), 2, anon_sym_RPAREN, - anon_sym_PIPE, - [55178] = 4, + anon_sym_RBRACK, + [55328] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2181), 1, + ACTIONS(2171), 1, sym_identifier, - ACTIONS(2184), 1, + ACTIONS(2173), 1, anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55192] = 2, + STATE(1074), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55342] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2186), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, + ACTIONS(2175), 1, + sym_identifier, + ACTIONS(2177), 1, anon_sym_EQ_GT, - [55202] = 2, + STATE(1175), 1, + aux_sym_handler_params_repeat1, + STATE(1751), 1, + sym_handler_params, + [55358] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2188), 4, + ACTIONS(2179), 1, anon_sym_COMMA, + STATE(1101), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2181), 2, + anon_sym_GT, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55212] = 4, + [55372] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2114), 1, - sym_identifier, - ACTIONS(2190), 1, - anon_sym_in, - STATE(1088), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55226] = 4, + ACTIONS(2183), 1, + anon_sym_COMMA, + STATE(1092), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2186), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [55386] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2192), 1, - sym_identifier, - ACTIONS(2195), 1, - anon_sym_in, - STATE(1088), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55240] = 2, + ACTIONS(2188), 1, + anon_sym_COMMA, + STATE(1092), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2190), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [55400] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2197), 4, + ACTIONS(2194), 1, + anon_sym_COLON, + ACTIONS(2192), 3, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55250] = 5, + anon_sym_PIPE, + [55412] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, + ACTIONS(1827), 1, + anon_sym_LT, + ACTIONS(1831), 1, + anon_sym_LBRACK, + ACTIONS(979), 2, + sym__statement_break, + anon_sym_where, + [55426] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2196), 1, sym_identifier, - ACTIONS(2199), 1, + ACTIONS(2198), 1, anon_sym_RPAREN, - STATE(1254), 1, + STATE(1144), 1, sym_extern_parameter, - STATE(1500), 1, + STATE(1388), 1, sym_extern_parameter_list, - [55266] = 2, + [55442] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2011), 1, + sym_identifier, + STATE(1325), 1, + sym_type_parameter, + ACTIONS(2013), 2, + anon_sym_in, + anon_sym_out, + [55456] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(697), 4, + ACTIONS(2200), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55276] = 4, + [55466] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2201), 1, + ACTIONS(2202), 1, anon_sym_COLON_COLON, - STATE(1075), 1, + STATE(1081), 1, aux_sym_import_target_repeat1, - ACTIONS(2204), 2, + ACTIONS(2205), 2, sym__statement_break, anon_sym_as, - [55290] = 2, + [55480] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2206), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55300] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2114), 1, + ACTIONS(2171), 1, sym_identifier, - ACTIONS(2208), 1, + ACTIONS(2207), 1, anon_sym_in, - STATE(1088), 2, + STATE(1074), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [55314] = 2, + [55494] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2210), 4, + ACTIONS(2179), 1, anon_sym_COMMA, + STATE(1114), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2209), 2, + anon_sym_GT, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55324] = 2, + [55508] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2212), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55334] = 5, + ACTIONS(2147), 1, + sym_identifier, + ACTIONS(2211), 1, + anon_sym_LBRACK, + STATE(978), 1, + sym_qualified_path, + STATE(1329), 1, + sym_effect_ref, + [55524] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, + ACTIONS(2196), 1, sym_identifier, - ACTIONS(2214), 1, + ACTIONS(2213), 1, anon_sym_RPAREN, - STATE(1254), 1, + STATE(1144), 1, sym_extern_parameter, - STATE(1368), 1, + STATE(1430), 1, sym_extern_parameter_list, - [55350] = 4, + [55540] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, + ACTIONS(2196), 1, sym_identifier, - ACTIONS(2216), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55364] = 2, + ACTIONS(2215), 1, + anon_sym_RPAREN, + STATE(1144), 1, + sym_extern_parameter, + STATE(1442), 1, + sym_extern_parameter_list, + [55556] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2218), 4, + ACTIONS(2217), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55374] = 4, + [55566] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, + ACTIONS(2171), 1, sym_identifier, - ACTIONS(2220), 1, + ACTIONS(2219), 1, anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55388] = 4, + STATE(1074), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55580] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, + ACTIONS(2221), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55590] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2188), 1, + anon_sym_COMMA, + STATE(1093), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2223), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [55604] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2225), 1, sym_identifier, - ACTIONS(2222), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55402] = 4, + ACTIONS(2227), 1, + anon_sym_RBRACE, + STATE(1166), 1, + sym_import_member, + STATE(1712), 1, + sym_import_member_list, + [55620] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, + ACTIONS(2196), 1, sym_identifier, - ACTIONS(2224), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55416] = 2, + ACTIONS(2229), 1, + anon_sym_RPAREN, + STATE(1144), 1, + sym_extern_parameter, + STATE(1401), 1, + sym_extern_parameter_list, + [55636] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2226), 4, + ACTIONS(2231), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55426] = 4, + [55646] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, - anon_sym_COMMA, - STATE(1083), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2230), 2, + ACTIONS(2196), 1, + sym_identifier, + ACTIONS(2233), 1, anon_sym_RPAREN, + STATE(1144), 1, + sym_extern_parameter, + STATE(1606), 1, + sym_extern_parameter_list, + [55662] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2128), 1, anon_sym_PIPE, - [55440] = 4, + STATE(1116), 1, + aux_sym_union_type_repeat1, + ACTIONS(1336), 2, + sym__statement_break, + anon_sym_where, + [55676] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2098), 1, + ACTIONS(2235), 1, anon_sym_COMMA, - STATE(1058), 1, + STATE(1114), 1, aux_sym_positional_payload_repeat1, - ACTIONS(2232), 2, + ACTIONS(2238), 2, anon_sym_GT, anon_sym_RPAREN, - [55454] = 4, + [55690] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1780), 1, - anon_sym_LT, - ACTIONS(1784), 1, - anon_sym_LBRACK, - ACTIONS(982), 2, + ACTIONS(2240), 1, + anon_sym_COLON_COLON, + STATE(1115), 1, + aux_sym_import_target_repeat1, + ACTIONS(2243), 2, + sym__statement_break, + anon_sym_as, + [55704] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2245), 1, + anon_sym_PIPE, + STATE(1116), 1, + aux_sym_union_type_repeat1, + ACTIONS(1338), 2, sym__statement_break, anon_sym_where, - [55468] = 5, + [55718] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, + ACTIONS(566), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55728] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2175), 1, sym_identifier, - ACTIONS(2234), 1, + ACTIONS(2248), 1, + anon_sym_EQ_GT, + STATE(1175), 1, + aux_sym_handler_params_repeat1, + STATE(1393), 1, + sym_handler_params, + [55744] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2250), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55754] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2196), 1, + sym_identifier, + ACTIONS(2252), 1, anon_sym_RPAREN, - STATE(1254), 1, + STATE(1144), 1, sym_extern_parameter, - STATE(1572), 1, + STATE(1701), 1, sym_extern_parameter_list, - [55484] = 2, + [55770] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1799), 4, - anon_sym_LBRACE, + ACTIONS(2254), 1, + anon_sym_RBRACE, + ACTIONS(2256), 1, anon_sym_COMMA, + STATE(1200), 1, + aux_sym_field_declarations_repeat1, + [55783] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2258), 1, anon_sym_EQ, - anon_sym_RBRACK, - [55494] = 4, + STATE(748), 1, + sym_block, + [55796] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2096), 1, - anon_sym_PIPE, - STATE(1057), 1, - aux_sym_union_type_repeat1, - ACTIONS(1337), 2, - sym__statement_break, - anon_sym_where, - [55508] = 5, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2260), 1, + anon_sym_EQ, + STATE(1703), 1, + sym_block, + [55809] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2236), 1, - sym_identifier, - STATE(969), 1, - sym_qualified_path, - STATE(1207), 1, - sym_effect_ref, - STATE(1440), 1, - sym_effect_list, - [55524] = 5, + ACTIONS(2262), 1, + anon_sym_RBRACE, + ACTIONS(2264), 1, + anon_sym_COMMA, + STATE(1124), 1, + aux_sym_field_pattern_repeat1, + [55822] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2236), 1, + ACTIONS(886), 1, + anon_sym_COMMA, + ACTIONS(1764), 1, + anon_sym_RBRACE, + STATE(1218), 1, + aux_sym_field_pattern_repeat1, + [55835] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2267), 1, sym_identifier, - STATE(969), 1, + STATE(644), 1, sym_qualified_path, - STATE(1207), 1, - sym_effect_ref, - STATE(1435), 1, - sym_effect_list, - [55540] = 2, + STATE(650), 1, + sym_variant, + [55848] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2238), 4, + ACTIONS(1364), 1, + sym__statement_break, + ACTIONS(2269), 1, + anon_sym_where, + STATE(1460), 1, + sym_type_validation, + [55861] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2271), 1, anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55550] = 5, + ACTIONS(2273), 1, + anon_sym_GT, + STATE(1266), 1, + aux_sym_type_parameter_list_repeat1, + [55874] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2236), 1, - sym_identifier, - ACTIONS(2240), 1, - anon_sym_LBRACK, - STATE(969), 1, - sym_qualified_path, - STATE(1292), 1, - sym_effect_ref, - [55566] = 4, + ACTIONS(2275), 1, + anon_sym_RBRACE, + ACTIONS(2277), 1, + anon_sym_COMMA, + STATE(1136), 1, + aux_sym_map_literal_repeat1, + [55887] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2118), 1, - sym_identifier, - ACTIONS(2242), 1, - anon_sym_in, - STATE(1084), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [55580] = 2, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(2053), 1, + anon_sym_DOT, + STATE(1608), 1, + sym_type_arguments, + [55900] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2244), 4, + ACTIONS(2279), 1, + anon_sym_RBRACE, + ACTIONS(2281), 1, anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55590] = 2, + STATE(1145), 1, + aux_sym_field_assignments_repeat1, + [55913] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2246), 4, + ACTIONS(2281), 1, anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55600] = 4, + ACTIONS(2283), 1, + anon_sym_RBRACE, + STATE(1131), 1, + aux_sym_field_assignments_repeat1, + [55926] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2228), 1, + ACTIONS(988), 1, anon_sym_COMMA, - STATE(1104), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2248), 2, - anon_sym_RPAREN, - anon_sym_PIPE, - [55614] = 4, + ACTIONS(2285), 1, + anon_sym_RBRACK, + STATE(1088), 1, + aux_sym_argument_list_repeat1, + [55939] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2250), 1, + ACTIONS(2287), 1, anon_sym_COMMA, - ACTIONS(2252), 1, - anon_sym_RPAREN, - STATE(1214), 1, - aux_sym_extern_parameter_list_repeat1, - [55627] = 4, + ACTIONS(2290), 1, + anon_sym_RBRACK, + STATE(1134), 1, + aux_sym_list_pattern_repeat1, + [55952] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1750), 1, - anon_sym_RBRACE, - ACTIONS(2254), 1, + ACTIONS(2147), 1, + sym_identifier, + STATE(978), 1, + sym_qualified_path, + STATE(1324), 1, + sym_effect_ref, + [55965] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2277), 1, anon_sym_COMMA, - STATE(1167), 1, - aux_sym_field_pattern_repeat1, - [55640] = 4, + ACTIONS(2292), 1, + anon_sym_RBRACE, + STATE(1156), 1, + aux_sym_map_literal_repeat1, + [55978] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2257), 1, - anon_sym_LBRACE, - ACTIONS(2259), 1, - anon_sym_if, - STATE(487), 1, - sym_if_expression, - [55653] = 4, + ACTIONS(2294), 1, + anon_sym_COMMA, + ACTIONS(2296), 1, + anon_sym_RBRACK, + STATE(1263), 1, + aux_sym_effect_list_repeat1, + [55991] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2261), 1, - sym_identifier, - ACTIONS(2264), 1, - anon_sym_EQ_GT, - STATE(1121), 1, - aux_sym_handler_params_repeat1, - [55666] = 2, + ACTIONS(988), 1, + anon_sym_COMMA, + ACTIONS(2298), 1, + anon_sym_RBRACK, + STATE(1088), 1, + aux_sym_argument_list_repeat1, + [56004] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2266), 3, + ACTIONS(2083), 1, + anon_sym_DOT, + ACTIONS(2300), 1, sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [55675] = 3, + STATE(1248), 1, + aux_sym_legacy_import_path_repeat1, + [56017] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2268), 1, - anon_sym_as, - ACTIONS(2270), 2, + ACTIONS(2302), 1, anon_sym_RBRACE, + ACTIONS(2304), 1, anon_sym_COMMA, - [55686] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(931), 1, - anon_sym_COMMA, - ACTIONS(2272), 1, - anon_sym_RBRACE, - STATE(1185), 1, - aux_sym_field_pattern_repeat1, - [55699] = 4, + STATE(1140), 1, + aux_sym_field_declarations_repeat1, + [56030] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2274), 1, - anon_sym_EQ, - STATE(755), 1, - sym_block, - [55712] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2276), 1, + ACTIONS(2307), 1, anon_sym_EQ, - STATE(1649), 1, + STATE(1557), 1, sym_block, - [55725] = 4, + [56043] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2278), 1, - sym_identifier, - STATE(644), 1, - sym_qualified_path, - STATE(649), 1, - sym_variant, - [55738] = 4, + ACTIONS(1354), 1, + sym__statement_break, + ACTIONS(2269), 1, + anon_sym_where, + STATE(1374), 1, + sym_type_validation, + [56056] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2280), 1, + ACTIONS(2309), 1, anon_sym_EQ, - STATE(1635), 1, + STATE(1738), 1, sym_block, - [55751] = 2, + [56069] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2094), 3, + ACTIONS(2311), 1, anon_sym_COMMA, - anon_sym_GT, + ACTIONS(2313), 1, anon_sym_RPAREN, - [55760] = 4, + STATE(1161), 1, + aux_sym_extern_parameter_list_repeat1, + [56082] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2282), 1, + ACTIONS(2315), 1, anon_sym_RBRACE, - ACTIONS(2284), 1, + ACTIONS(2317), 1, anon_sym_COMMA, - STATE(1181), 1, + STATE(1145), 1, aux_sym_field_assignments_repeat1, - [55773] = 4, + [56095] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2286), 1, + ACTIONS(2320), 1, anon_sym_EQ, - STATE(1728), 1, + STATE(1531), 1, sym_block, - [55786] = 4, + [56108] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2288), 1, - anon_sym_RBRACE, - ACTIONS(2290), 1, - anon_sym_COMMA, - STATE(1148), 1, - aux_sym_map_literal_repeat1, - [55799] = 4, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2322), 1, + anon_sym_EQ, + STATE(1663), 1, + sym_block, + [56121] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2292), 1, + ACTIONS(2324), 1, sym_identifier, - ACTIONS(2294), 1, - anon_sym_EQ_GT, STATE(1121), 1, - aux_sym_handler_params_repeat1, - [55812] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1345), 1, - sym__statement_break, - ACTIONS(2296), 1, - anon_sym_where, - STATE(1739), 1, - sym_type_validation, - [55825] = 4, + sym_field_declaration, + STATE(1595), 1, + sym_field_declarations, + [56134] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2298), 1, - anon_sym_EQ, - STATE(703), 1, - sym_block, - [55838] = 4, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1523), 1, + sym_field_assignments, + [56147] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2300), 1, + ACTIONS(2328), 1, anon_sym_COMMA, - ACTIONS(2303), 1, - anon_sym_RPAREN, - STATE(1136), 1, - aux_sym_tuple_pattern_repeat1, - [55851] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2305), 1, - anon_sym_LBRACE, - ACTIONS(2307), 1, - anon_sym_if, - STATE(287), 1, - sym_if_expression, - [55864] = 4, + ACTIONS(2330), 1, + anon_sym_GT, + STATE(1181), 1, + aux_sym__call_type_list_repeat1, + [56160] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2309), 1, - anon_sym_RBRACE, - ACTIONS(2311), 1, + ACTIONS(2332), 3, anon_sym_COMMA, - STATE(1138), 1, - aux_sym_field_assignments_repeat1, - [55877] = 4, + anon_sym_RPAREN, + anon_sym_PIPE, + [56169] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2314), 1, + ACTIONS(2334), 1, anon_sym_EQ, - STATE(706), 1, + STATE(1637), 1, sym_block, - [55890] = 4, + [56182] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2236), 1, + ACTIONS(2336), 1, sym_identifier, - STATE(969), 1, + STATE(1009), 1, sym_qualified_path, - STATE(1359), 1, - sym_effect_ref, - [55903] = 4, + STATE(1202), 1, + sym_variant, + [56195] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2316), 1, + ACTIONS(2338), 1, anon_sym_COMMA, - ACTIONS(2319), 1, - anon_sym_RBRACK, - STATE(1141), 1, - aux_sym_list_pattern_repeat1, - [55916] = 4, + ACTIONS(2340), 1, + anon_sym_RPAREN, + STATE(1242), 1, + aux_sym_pattern_repeat1, + [56208] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2321), 1, - anon_sym_COMMA, - ACTIONS(2323), 1, - anon_sym_RBRACK, - STATE(1172), 1, - aux_sym_effect_list_repeat1, - [55929] = 4, + ACTIONS(2342), 1, + anon_sym_LBRACE, + ACTIONS(2344), 1, + anon_sym_if, + STATE(381), 1, + sym_if_expression, + [56221] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2325), 1, + ACTIONS(2346), 1, anon_sym_RBRACE, - ACTIONS(2327), 1, + ACTIONS(2348), 1, anon_sym_COMMA, - STATE(1217), 1, - aux_sym_field_declarations_repeat1, - [55942] = 4, + STATE(1156), 1, + aux_sym_map_literal_repeat1, + [56234] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(988), 1, + anon_sym_COMMA, + ACTIONS(2351), 1, + anon_sym_RPAREN, + STATE(1088), 1, + aux_sym_argument_list_repeat1, + [56247] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2329), 1, + ACTIONS(2353), 1, anon_sym_LBRACE, - ACTIONS(2331), 1, + ACTIONS(2355), 1, anon_sym_COLON, - STATE(1480), 1, + STATE(1494), 1, sym_signature_ascription, - [55955] = 4, + [56260] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2333), 1, - anon_sym_EQ, - STATE(1664), 1, - sym_block, - [55968] = 4, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1555), 1, + sym_field_assignments, + [56273] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2335), 1, - anon_sym_EQ, - STATE(713), 1, - sym_block, - [55981] = 4, + ACTIONS(1875), 1, + sym_identifier, + STATE(1040), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [56284] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2337), 1, + ACTIONS(2311), 1, anon_sym_COMMA, - ACTIONS(2339), 1, + ACTIONS(2357), 1, anon_sym_RPAREN, - STATE(1249), 1, - aux_sym_pattern_repeat1, - [55994] = 4, + STATE(1236), 1, + aux_sym_extern_parameter_list_repeat1, + [56297] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 1, + STATE(1190), 1, + sym_parameter, + ACTIONS(2015), 2, + anon_sym__, + sym_identifier, + [56308] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2328), 1, anon_sym_COMMA, - ACTIONS(2341), 1, + ACTIONS(2359), 1, + anon_sym_GT, + STATE(1181), 1, + aux_sym__call_type_list_repeat1, + [56321] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2361), 1, + anon_sym_as, + ACTIONS(2363), 2, anon_sym_RBRACE, - STATE(1149), 1, - aux_sym_map_literal_repeat1, - [56007] = 4, + anon_sym_COMMA, + [56332] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2365), 1, + sym_identifier, + STATE(1106), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [56343] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2343), 1, + ACTIONS(2367), 1, anon_sym_RBRACE, - ACTIONS(2345), 1, + ACTIONS(2369), 1, anon_sym_COMMA, - STATE(1149), 1, - aux_sym_map_literal_repeat1, - [56020] = 4, + STATE(1243), 1, + aux_sym_import_member_list_repeat1, + [56356] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2348), 1, + ACTIONS(2371), 1, anon_sym_EQ, - STATE(720), 1, + STATE(1641), 1, sym_block, - [56033] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2350), 1, - anon_sym_COMMA, - ACTIONS(2352), 1, - anon_sym_RPAREN, - STATE(1136), 1, - aux_sym_tuple_pattern_repeat1, - [56046] = 4, + [56369] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2354), 1, + ACTIONS(2373), 1, anon_sym_RBRACE, - ACTIONS(2356), 1, + ACTIONS(2375), 1, anon_sym_COMMA, - STATE(1176), 1, + STATE(1168), 1, aux_sym_import_member_list_repeat1, - [56059] = 4, + [56382] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2358), 1, + ACTIONS(2378), 1, anon_sym_EQ, - STATE(724), 1, + STATE(698), 1, sym_block, - [56072] = 3, + [56395] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, - sym_identifier, - STATE(1080), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [56083] = 4, + ACTIONS(1343), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56404] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2360), 1, - anon_sym_EQ, - STATE(726), 1, - sym_block, - [56096] = 4, + ACTIONS(2277), 1, + anon_sym_COMMA, + ACTIONS(2380), 1, + anon_sym_RBRACE, + STATE(1156), 1, + aux_sym_map_literal_repeat1, + [56417] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2362), 1, - anon_sym_EQ, - STATE(1364), 1, - sym_block, - [56109] = 4, + ACTIONS(1358), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56426] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2382), 1, anon_sym_LBRACE, - ACTIONS(2364), 1, - anon_sym_EQ, - STATE(729), 1, - sym_block, - [56122] = 4, + STATE(1587), 1, + sym_signature_ascription, + [56439] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2366), 1, - anon_sym_COMMA, - ACTIONS(2368), 1, - anon_sym_RBRACK, - STATE(1141), 1, - aux_sym_list_pattern_repeat1, - [56135] = 4, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1755), 1, + sym_field_assignments, + [56452] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2384), 1, + sym_identifier, + ACTIONS(2386), 1, + anon_sym_EQ_GT, + STATE(1213), 1, + aux_sym_handler_params_repeat1, + [56465] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2331), 1, + ACTIONS(2355), 1, anon_sym_COLON, - ACTIONS(2370), 1, + ACTIONS(2388), 1, anon_sym_LBRACE, - STATE(1724), 1, + STATE(1688), 1, sym_signature_ascription, - [56148] = 4, + [56478] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1373), 1, + sym_field_assignments, + [56491] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2390), 1, anon_sym_LBRACE, - ACTIONS(2372), 1, - anon_sym_EQ, - STATE(736), 1, - sym_block, - [56161] = 4, + ACTIONS(2392), 1, + anon_sym_if, + STATE(285), 1, + sym_if_expression, + [56504] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2374), 1, + ACTIONS(2394), 1, anon_sym_EQ, - STATE(737), 1, + STATE(1674), 1, sym_block, - [56174] = 4, + [56517] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2376), 1, + ACTIONS(2085), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [56526] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2396), 1, anon_sym_COMMA, - ACTIONS(2378), 1, - anon_sym_RPAREN, - STATE(1182), 1, - aux_sym_named_argument_list_repeat1, - [56187] = 4, + ACTIONS(2399), 1, + anon_sym_GT, + STATE(1181), 1, + aux_sym__call_type_list_repeat1, + [56539] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1875), 1, + sym_identifier, + STATE(1002), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [56550] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2401), 1, anon_sym_LBRACE, - ACTIONS(2380), 1, - anon_sym_EQ, - STATE(739), 1, - sym_block, - [56200] = 4, + STATE(1600), 1, + sym_signature_ascription, + [56563] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1021), 1, - anon_sym_COMMA, - ACTIONS(2382), 1, - anon_sym_RBRACK, - STATE(1062), 1, - aux_sym_argument_list_repeat1, - [56213] = 4, + STATE(1238), 1, + sym_namespace_name, + ACTIONS(2403), 2, + sym_string, + sym_identifier, + [56574] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2384), 1, - anon_sym_EQ, - STATE(741), 1, - sym_block, - [56226] = 4, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1390), 1, + sym_field_assignments, + [56587] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2386), 1, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2405), 1, anon_sym_LBRACE, - ACTIONS(2388), 1, - anon_sym_SEMI, - STATE(1464), 1, - sym_namespace_body, - [56239] = 4, + STATE(1610), 1, + sym_signature_ascription, + [56600] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2272), 1, + ACTIONS(2407), 1, anon_sym_RBRACE, - ACTIONS(2390), 1, + ACTIONS(2409), 1, anon_sym_COMMA, - STATE(1185), 1, + STATE(1124), 1, aux_sym_field_pattern_repeat1, - [56252] = 4, + [56613] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2393), 1, - anon_sym_EQ, - STATE(744), 1, - sym_block, - [56265] = 4, + ACTIONS(2324), 1, + sym_identifier, + STATE(1121), 1, + sym_field_declaration, + STATE(1402), 1, + sym_field_declarations, + [56626] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2395), 1, - anon_sym_EQ, - STATE(745), 1, - sym_block, - [56278] = 4, + ACTIONS(1875), 1, + sym_identifier, + STATE(1006), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [56637] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2186), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_PIPE, + [56646] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2271), 1, + anon_sym_COMMA, + ACTIONS(2412), 1, + anon_sym_GT, + STATE(1128), 1, + aux_sym_type_parameter_list_repeat1, + [56659] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2397), 1, + ACTIONS(2414), 1, anon_sym_EQ, - STATE(746), 1, + STATE(702), 1, sym_block, - [56291] = 4, + [56672] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2399), 1, + ACTIONS(2416), 1, anon_sym_EQ, - STATE(750), 1, + STATE(1448), 1, sym_block, - [56304] = 4, + [56685] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2401), 1, + ACTIONS(2294), 1, anon_sym_COMMA, - ACTIONS(2404), 1, + ACTIONS(2418), 1, anon_sym_RBRACK, - STATE(1172), 1, + STATE(1137), 1, aux_sym_effect_list_repeat1, - [56317] = 4, + [56698] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 1, + ACTIONS(2420), 1, anon_sym_COMMA, - ACTIONS(2406), 1, - anon_sym_RBRACE, - STATE(1244), 1, - aux_sym_map_literal_repeat1, - [56330] = 4, + ACTIONS(2423), 1, + anon_sym_RPAREN, + STATE(1195), 1, + aux_sym_named_argument_list_repeat1, + [56711] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 1, - anon_sym_COMMA, - ACTIONS(2408), 1, - anon_sym_RBRACE, - STATE(1178), 1, - aux_sym_map_literal_repeat1, - [56343] = 4, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2425), 1, + anon_sym_LBRACE, + STATE(1622), 1, + sym_signature_ascription, + [56724] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2410), 1, - anon_sym_COMMA, - ACTIONS(2412), 1, - anon_sym_RBRACK, - STATE(1158), 1, - aux_sym_list_pattern_repeat1, - [56356] = 4, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2427), 1, + anon_sym_EQ, + STATE(1522), 1, + sym_block, + [56737] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2356), 1, - anon_sym_COMMA, - ACTIONS(2414), 1, - anon_sym_RBRACE, - STATE(1199), 1, - aux_sym_import_member_list_repeat1, - [56369] = 4, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2429), 1, + anon_sym_LBRACE, + STATE(1467), 1, + sym_signature_ascription, + [56750] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2098), 1, - anon_sym_COMMA, - ACTIONS(2416), 1, - anon_sym_RPAREN, - STATE(1221), 1, - aux_sym_positional_payload_repeat1, - [56382] = 4, + ACTIONS(2324), 1, + sym_identifier, + STATE(1121), 1, + sym_field_declaration, + STATE(1431), 1, + sym_field_declarations, + [56763] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 1, + ACTIONS(2256), 1, anon_sym_COMMA, - ACTIONS(2418), 1, + ACTIONS(2431), 1, anon_sym_RBRACE, - STATE(1149), 1, - aux_sym_map_literal_repeat1, - [56395] = 4, + STATE(1140), 1, + aux_sym_field_declarations_repeat1, + [56776] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2420), 1, + ACTIONS(2324), 1, sym_identifier, - ACTIONS(2422), 1, - sym_static_stage, - STATE(1024), 1, - sym_qualified_path, - [56408] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1021), 1, - anon_sym_COMMA, - ACTIONS(2424), 1, - anon_sym_RBRACK, - STATE(1062), 1, - aux_sym_argument_list_repeat1, - [56421] = 4, + STATE(1121), 1, + sym_field_declaration, + STATE(1548), 1, + sym_field_declarations, + [56789] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2284), 1, - anon_sym_COMMA, - ACTIONS(2426), 1, - anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_field_assignments_repeat1, - [56434] = 4, + ACTIONS(1338), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56798] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2428), 1, + ACTIONS(2433), 1, anon_sym_COMMA, - ACTIONS(2431), 1, + ACTIONS(2436), 1, anon_sym_RPAREN, - STATE(1182), 1, - aux_sym_named_argument_list_repeat1, - [56447] = 4, + STATE(1203), 1, + aux_sym_tuple_pattern_repeat1, + [56811] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2337), 1, - anon_sym_COMMA, - ACTIONS(2433), 1, - anon_sym_RPAREN, - STATE(1147), 1, - aux_sym_pattern_repeat1, - [56460] = 4, + ACTIONS(2365), 1, + sym_identifier, + STATE(1089), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [56822] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2435), 1, + ACTIONS(2438), 1, anon_sym_EQ, - STATE(1376), 1, + STATE(1571), 1, sym_block, - [56473] = 4, + [56835] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2437), 1, - anon_sym_RBRACE, - ACTIONS(2439), 1, - anon_sym_COMMA, - STATE(1185), 1, - aux_sym_field_pattern_repeat1, - [56486] = 4, + ACTIONS(1360), 1, + sym__statement_break, + ACTIONS(2269), 1, + anon_sym_where, + STATE(1411), 1, + sym_type_validation, + [56848] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2442), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - STATE(1674), 1, - sym_signature_ascription, - [56499] = 3, + ACTIONS(2440), 1, + anon_sym_EQ, + STATE(712), 1, + sym_block, + [56861] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1166), 1, - sym_namespace_name, - ACTIONS(2444), 2, - sym_string, - sym_identifier, - [56510] = 4, + ACTIONS(2179), 1, + anon_sym_COMMA, + ACTIONS(2442), 1, + anon_sym_RPAREN, + STATE(1211), 1, + aux_sym_positional_payload_repeat1, + [56874] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, + ACTIONS(2444), 1, + anon_sym_COMMA, ACTIONS(2446), 1, - anon_sym_EQ, - STATE(1520), 1, - sym_block, - [56523] = 4, + anon_sym_RBRACK, + STATE(1240), 1, + aux_sym_list_pattern_repeat1, + [56887] = 4, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2277), 1, + anon_sym_COMMA, ACTIONS(2448), 1, - sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1370), 1, - sym_field_assignments, - [56536] = 4, + anon_sym_RBRACE, + STATE(1245), 1, + aux_sym_map_literal_repeat1, + [56900] = 4, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2179), 1, + anon_sym_COMMA, ACTIONS(2450), 1, - anon_sym_LBRACE, + anon_sym_RPAREN, + STATE(1114), 1, + aux_sym_positional_payload_repeat1, + [56913] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1362), 1, + sym__statement_break, + ACTIONS(2269), 1, + anon_sym_where, + STATE(1584), 1, + sym_type_validation, + [56926] = 4, + ACTIONS(298), 1, + sym_line_comment, ACTIONS(2452), 1, - anon_sym_if, - STATE(380), 1, - sym_if_expression, - [56549] = 4, + sym_identifier, + ACTIONS(2455), 1, + anon_sym_EQ_GT, + STATE(1213), 1, + aux_sym_handler_params_repeat1, + [56939] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2457), 1, + anon_sym_COMMA, + ACTIONS(2459), 1, + anon_sym_RPAREN, + STATE(1239), 1, + aux_sym_named_argument_list_repeat1, + [56952] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2365), 1, + sym_identifier, + STATE(1100), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [56963] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2454), 1, + ACTIONS(2461), 1, anon_sym_EQ, - STATE(1389), 1, + STATE(720), 1, sym_block, - [56562] = 3, + [56976] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1250), 1, - sym_parameter, - ACTIONS(2009), 2, - anon_sym__, - sym_identifier, - [56573] = 4, + ACTIONS(988), 1, + anon_sym_COMMA, + ACTIONS(2463), 1, + anon_sym_RBRACK, + STATE(1088), 1, + aux_sym_argument_list_repeat1, + [56989] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(886), 1, + anon_sym_COMMA, + ACTIONS(2407), 1, + anon_sym_RBRACE, + STATE(1124), 1, + aux_sym_field_pattern_repeat1, + [57002] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2456), 1, + ACTIONS(2465), 1, anon_sym_EQ, - STATE(1397), 1, + STATE(1497), 1, sym_block, - [56586] = 3, + [57015] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2458), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(1063), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [56597] = 4, + STATE(1041), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [57026] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2460), 1, + ACTIONS(2328), 1, anon_sym_COMMA, - ACTIONS(2462), 1, + ACTIONS(2467), 1, anon_sym_GT, - STATE(1226), 1, - aux_sym_type_parameter_list_repeat1, - [56610] = 4, + STATE(1150), 1, + aux_sym__call_type_list_repeat1, + [57039] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2464), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - STATE(1577), 1, - sym_signature_ascription, - [56623] = 4, + ACTIONS(2469), 1, + anon_sym_EQ, + STATE(724), 1, + sym_block, + [57052] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, + ACTIONS(2326), 1, sym_identifier, - STATE(1130), 1, + STATE(1132), 1, sym_field_assignment, - STATE(1747), 1, + STATE(1514), 1, sym_field_assignments, - [56636] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2466), 1, - anon_sym_COMMA, - ACTIONS(2469), 1, - anon_sym_GT, - STATE(1198), 1, - aux_sym_type_parameter_list_repeat1, - [56649] = 4, + [57065] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(2471), 1, - anon_sym_RBRACE, + anon_sym_LBRACE, ACTIONS(2473), 1, - anon_sym_COMMA, - STATE(1199), 1, - aux_sym_import_member_list_repeat1, - [56662] = 4, + anon_sym_SEMI, + STATE(1457), 1, + sym_namespace_body, + [57078] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, + ACTIONS(2326), 1, sym_identifier, - STATE(1130), 1, + STATE(1132), 1, sym_field_assignment, - STATE(1363), 1, + STATE(1519), 1, sym_field_assignments, - [56675] = 4, + [57091] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2475), 1, + anon_sym_EQ, + STATE(726), 1, + sym_block, + [57104] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2476), 1, + ACTIONS(2477), 1, sym_identifier, - STATE(1255), 1, - sym_field_declaration, - STATE(1585), 1, - sym_field_declarations, - [56688] = 3, + ACTIONS(2479), 1, + sym_static_stage, + STATE(1021), 1, + sym_qualified_path, + [57117] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(1071), 2, + STATE(1030), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [56699] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2478), 1, - anon_sym_LBRACE, - STATE(1590), 1, - sym_signature_ascription, - [56712] = 4, + [57128] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(2481), 1, anon_sym_LBRACE, - ACTIONS(2480), 1, - anon_sym_EQ, - STATE(1563), 1, - sym_block, - [56725] = 4, + ACTIONS(2483), 1, + anon_sym_if, + STATE(509), 1, + sym_if_expression, + [57141] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, + ACTIONS(2326), 1, sym_identifier, - STATE(1130), 1, + STATE(1132), 1, sym_field_assignment, - STATE(1380), 1, + STATE(1525), 1, sym_field_assignments, - [56738] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2482), 1, - anon_sym_LBRACE, - STATE(1600), 1, - sym_signature_ascription, - [56751] = 4, + [57154] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2321), 1, + ACTIONS(2238), 3, anon_sym_COMMA, - ACTIONS(2484), 1, - anon_sym_RBRACK, - STATE(1142), 1, - aux_sym_effect_list_repeat1, - [56764] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2476), 1, - sym_identifier, - STATE(1255), 1, - sym_field_declaration, - STATE(1392), 1, - sym_field_declarations, - [56777] = 3, + anon_sym_GT, + anon_sym_RPAREN, + [57163] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, + ACTIONS(1875), 1, sym_identifier, - STATE(1076), 2, + STATE(1031), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [56788] = 4, + [57174] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1360), 1, - sym__statement_break, - ACTIONS(2296), 1, - anon_sym_where, - STATE(1598), 1, - sym_type_validation, - [56801] = 4, + ACTIONS(2485), 1, + anon_sym_COMMA, + ACTIONS(2487), 1, + anon_sym_RPAREN, + STATE(1203), 1, + aux_sym_tuple_pattern_repeat1, + [57187] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2486), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - STATE(1612), 1, - sym_signature_ascription, - [56814] = 4, + ACTIONS(2489), 1, + anon_sym_EQ, + STATE(729), 1, + sym_block, + [57200] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2331), 1, - anon_sym_COLON, - ACTIONS(2488), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - STATE(1501), 1, - sym_signature_ascription, - [56827] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2476), 1, - sym_identifier, - STATE(1255), 1, - sym_field_declaration, - STATE(1421), 1, - sym_field_declarations, - [56840] = 4, + ACTIONS(2491), 1, + anon_sym_EQ, + STATE(1624), 1, + sym_block, + [57213] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2490), 1, - anon_sym_COMMA, ACTIONS(2493), 1, + anon_sym_COMMA, + ACTIONS(2496), 1, anon_sym_RPAREN, - STATE(1214), 1, + STATE(1236), 1, aux_sym_extern_parameter_list_repeat1, - [56853] = 3, + [57226] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2497), 1, - anon_sym_where, - ACTIONS(2495), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [56864] = 4, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2498), 1, + anon_sym_EQ, + STATE(1603), 1, + sym_block, + [57239] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1021), 1, + ACTIONS(2471), 1, + anon_sym_LBRACE, + ACTIONS(2500), 1, + anon_sym_SEMI, + STATE(1639), 1, + sym_namespace_body, + [57252] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2457), 1, anon_sym_COMMA, - ACTIONS(2499), 1, + ACTIONS(2502), 1, anon_sym_RPAREN, - STATE(1062), 1, - aux_sym_argument_list_repeat1, - [56877] = 4, + STATE(1195), 1, + aux_sym_named_argument_list_repeat1, + [57265] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2501), 1, - anon_sym_RBRACE, - ACTIONS(2503), 1, + ACTIONS(2504), 1, anon_sym_COMMA, - STATE(1217), 1, - aux_sym_field_declarations_repeat1, - [56890] = 2, + ACTIONS(2506), 1, + anon_sym_RBRACK, + STATE(1134), 1, + aux_sym_list_pattern_repeat1, + [57278] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [56899] = 4, + ACTIONS(2508), 1, + sym_identifier, + ACTIONS(2510), 1, + sym_static_stage, + STATE(1038), 1, + sym_qualified_path, + [57291] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(2065), 1, - anon_sym_DOT, - STATE(1648), 1, - sym_type_arguments, - [56912] = 2, + ACTIONS(2512), 1, + anon_sym_COMMA, + ACTIONS(2515), 1, + anon_sym_RPAREN, + STATE(1242), 1, + aux_sym_pattern_repeat1, + [57304] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1343), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [56921] = 4, + ACTIONS(2369), 1, + anon_sym_COMMA, + ACTIONS(2517), 1, + anon_sym_RBRACE, + STATE(1168), 1, + aux_sym_import_member_list_repeat1, + [57317] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2098), 1, + ACTIONS(2338), 1, anon_sym_COMMA, - ACTIONS(2506), 1, + ACTIONS(2519), 1, anon_sym_RPAREN, - STATE(1056), 1, - aux_sym_positional_payload_repeat1, - [56934] = 4, + STATE(1154), 1, + aux_sym_pattern_repeat1, + [57330] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1351), 1, - sym__statement_break, - ACTIONS(2296), 1, - anon_sym_where, - STATE(1579), 1, - sym_type_validation, - [56947] = 4, + ACTIONS(2277), 1, + anon_sym_COMMA, + ACTIONS(2521), 1, + anon_sym_RBRACE, + STATE(1156), 1, + aux_sym_map_literal_repeat1, + [57343] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, + ACTIONS(2355), 1, + anon_sym_COLON, + ACTIONS(2523), 1, + anon_sym_LBRACE, + STATE(1678), 1, + sym_signature_ascription, + [57356] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2525), 1, sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1424), 1, - sym_field_assignments, - [56960] = 4, + ACTIONS(2527), 1, + sym_static_stage, + STATE(1054), 1, + sym_qualified_path, + [57369] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2067), 1, + ACTIONS(2529), 1, anon_sym_DOT, - ACTIONS(2508), 1, + ACTIONS(2532), 1, sym__statement_break, - STATE(1241), 1, + STATE(1248), 1, aux_sym_legacy_import_path_repeat1, - [56973] = 3, + [57382] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1228), 1, - sym_namespace_name, - ACTIONS(2444), 2, - sym_string, - sym_identifier, - [56984] = 4, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2534), 1, + anon_sym_EQ, + STATE(736), 1, + sym_block, + [57395] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2460), 1, - anon_sym_COMMA, - ACTIONS(2510), 1, - anon_sym_GT, - STATE(1198), 1, - aux_sym_type_parameter_list_repeat1, - [56997] = 3, + ACTIONS(2536), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [57404] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2458), 1, - sym_identifier, - STATE(1094), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [57008] = 4, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2538), 1, + anon_sym_EQ, + STATE(737), 1, + sym_block, + [57417] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2386), 1, - anon_sym_LBRACE, - ACTIONS(2512), 1, - anon_sym_SEMI, - STATE(1651), 1, - sym_namespace_body, - [57021] = 4, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(2118), 1, + anon_sym_DOT, + STATE(1735), 1, + sym_type_arguments, + [57430] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1949), 1, anon_sym_LBRACE, - ACTIONS(2514), 1, + ACTIONS(2540), 1, anon_sym_EQ, - STATE(1450), 1, + STATE(1410), 1, sym_block, - [57034] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1332), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [57043] = 4, + [57443] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1021), 1, + ACTIONS(2277), 1, anon_sym_COMMA, - ACTIONS(2516), 1, - anon_sym_RBRACK, - STATE(1062), 1, - aux_sym_argument_list_repeat1, - [57056] = 4, + ACTIONS(2542), 1, + anon_sym_RBRACE, + STATE(1171), 1, + aux_sym_map_literal_repeat1, + [57456] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2518), 1, + ACTIONS(2544), 1, anon_sym_EQ, - STATE(1420), 1, + STATE(739), 1, sym_block, - [57069] = 4, + [57469] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, - sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1504), 1, - sym_field_assignments, - [57082] = 4, + ACTIONS(1949), 1, + anon_sym_LBRACE, + ACTIONS(2546), 1, + anon_sym_EQ, + STATE(1513), 1, + sym_block, + [57482] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, + ACTIONS(1933), 1, anon_sym_LBRACE, - ACTIONS(2520), 1, + ACTIONS(2548), 1, anon_sym_EQ, - STATE(1536), 1, + STATE(741), 1, sym_block, - [57095] = 4, + [57495] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, - sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1509), 1, - sym_field_assignments, - [57108] = 3, + ACTIONS(2328), 1, + anon_sym_COMMA, + ACTIONS(2550), 1, + anon_sym_GT, + STATE(1163), 1, + aux_sym__call_type_list_repeat1, + [57508] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, - sym_identifier, - STATE(1101), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [57119] = 2, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2552), 1, + anon_sym_EQ, + STATE(717), 1, + sym_block, + [57521] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2069), 3, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [57128] = 4, + ACTIONS(1833), 1, + anon_sym_LT2, + ACTIONS(2124), 1, + anon_sym_DOT, + STATE(1746), 1, + sym_type_arguments, + [57534] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, - sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1515), 1, - sym_field_assignments, - [57141] = 3, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2554), 1, + anon_sym_EQ, + STATE(744), 1, + sym_block, + [57547] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, - sym_identifier, - STATE(1102), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [57152] = 4, + ACTIONS(2558), 1, + anon_sym_where, + ACTIONS(2556), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57558] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2376), 1, + ACTIONS(2560), 1, anon_sym_COMMA, - ACTIONS(2522), 1, - anon_sym_RPAREN, - STATE(1162), 1, - aux_sym_named_argument_list_repeat1, - [57165] = 4, + ACTIONS(2563), 1, + anon_sym_RBRACK, + STATE(1263), 1, + aux_sym_effect_list_repeat1, + [57571] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2524), 1, - anon_sym_DOT, - ACTIONS(2527), 1, - sym__statement_break, - STATE(1241), 1, - aux_sym_legacy_import_path_repeat1, - [57178] = 2, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2565), 1, + anon_sym_EQ, + STATE(745), 1, + sym_block, + [57584] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2529), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_PIPE, - [57187] = 3, + ACTIONS(1933), 1, + anon_sym_LBRACE, + ACTIONS(2567), 1, + anon_sym_EQ, + STATE(689), 1, + sym_block, + [57597] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2458), 1, - sym_identifier, - STATE(1087), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [57198] = 4, + ACTIONS(2569), 1, + anon_sym_COMMA, + ACTIONS(2572), 1, + anon_sym_GT, + STATE(1266), 1, + aux_sym_type_parameter_list_repeat1, + [57610] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2290), 1, - anon_sym_COMMA, - ACTIONS(2531), 1, + ACTIONS(1764), 1, anon_sym_RBRACE, - STATE(1149), 1, - aux_sym_map_literal_repeat1, - [57211] = 4, + ACTIONS(2574), 1, + anon_sym_COMMA, + STATE(1187), 1, + aux_sym_field_pattern_repeat1, + [57623] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2533), 1, + STATE(1224), 1, + sym_namespace_name, + ACTIONS(2403), 2, + sym_string, sym_identifier, - ACTIONS(2535), 1, - sym_static_stage, - STATE(1039), 1, - sym_qualified_path, - [57224] = 4, + [57634] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2537), 1, - anon_sym_EQ, - STATE(1429), 1, - sym_block, - [57237] = 4, + ACTIONS(2326), 1, + sym_identifier, + STATE(1132), 1, + sym_field_assignment, + STATE(1372), 1, + sym_field_assignments, + [57647] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(931), 1, - anon_sym_COMMA, - ACTIONS(1750), 1, - anon_sym_RBRACE, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, - [57250] = 4, + ACTIONS(2577), 1, + sym_identifier, + STATE(1252), 1, + sym_qualified_path, + [57657] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2539), 1, + ACTIONS(2579), 1, sym_identifier, - ACTIONS(2541), 1, - sym_static_stage, - STATE(1021), 1, - sym_qualified_path, - [57263] = 4, + STATE(1298), 1, + sym_field_pattern, + [57667] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2543), 1, - anon_sym_COMMA, - ACTIONS(2546), 1, - anon_sym_RPAREN, - STATE(1249), 1, - aux_sym_pattern_repeat1, - [57276] = 2, + ACTIONS(1380), 1, + sym__statement_break, + ACTIONS(2581), 1, + anon_sym_DASH_GT, + [57677] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2179), 3, + ACTIONS(2423), 2, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_PIPE, - [57285] = 4, + [57685] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1349), 1, + ACTIONS(1368), 2, sym__statement_break, - ACTIONS(2296), 1, anon_sym_where, - STATE(1388), 1, - sym_type_validation, - [57298] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(2081), 1, - anon_sym_DOT, - STATE(1725), 1, - sym_type_arguments, - [57311] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2548), 1, - anon_sym_EQ, - STATE(1446), 1, - sym_block, - [57324] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2250), 1, - anon_sym_COMMA, - ACTIONS(2550), 1, - anon_sym_RPAREN, - STATE(1118), 1, - aux_sym_extern_parameter_list_repeat1, - [57337] = 4, + [57693] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2327), 1, + ACTIONS(2583), 2, anon_sym_COMMA, - ACTIONS(2552), 1, - anon_sym_RBRACE, - STATE(1143), 1, - aux_sym_field_declarations_repeat1, - [57350] = 4, + anon_sym_GT, + [57701] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2476), 1, + ACTIONS(2585), 2, + anon_sym__, sym_identifier, - STATE(1255), 1, - sym_field_declaration, - STATE(1573), 1, - sym_field_declarations, - [57363] = 4, + [57709] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2554), 1, - sym_identifier, - STATE(1005), 1, - sym_qualified_path, - STATE(1230), 1, - sym_variant, - [57376] = 4, + ACTIONS(1404), 1, + sym__statement_break, + ACTIONS(2587), 1, + anon_sym_DASH_GT, + [57719] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1829), 1, - anon_sym_LT2, - ACTIONS(2085), 1, - anon_sym_DOT, - STATE(1736), 1, - sym_type_arguments, - [57389] = 4, + ACTIONS(2589), 1, + sym_identifier, + STATE(838), 1, + sym_symbol_path, + [57729] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1929), 1, - anon_sym_LBRACE, - ACTIONS(2556), 1, - anon_sym_EQ, - STATE(1437), 1, - sym_block, - [57402] = 4, + ACTIONS(2591), 1, + sym_float, + ACTIONS(2593), 1, + sym_integer, + [57739] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, - sym_identifier, - STATE(1130), 1, - sym_field_assignment, - STATE(1513), 1, - sym_field_assignments, - [57415] = 3, + ACTIONS(2595), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57747] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, - sym_identifier, - STATE(1065), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [57426] = 3, + ACTIONS(2373), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57755] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2558), 1, + ACTIONS(1756), 1, anon_sym_LBRACE, - ACTIONS(2560), 1, - anon_sym_LT, - [57436] = 3, + ACTIONS(1762), 1, + anon_sym_LPAREN, + [57765] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2562), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1459), 1, - sym_field_pattern, - [57446] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1402), 2, - sym__statement_break, - anon_sym_where, - [57454] = 3, + STATE(1246), 1, + sym_symbol_path, + [57775] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2564), 1, - sym_identifier, - STATE(1051), 1, - sym_qualified_path, - [57464] = 3, + ACTIONS(2599), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57783] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2566), 1, - anon_sym_DASH_GT, - ACTIONS(2568), 1, - anon_sym_EQ_GT, - [57474] = 3, + ACTIONS(2496), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [57791] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2570), 1, - sym_float, - ACTIONS(2572), 1, - sym_integer, - [57484] = 2, + ACTIONS(2302), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [57799] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1270), 2, - sym__statement_break, - anon_sym_where, - [57492] = 3, + ACTIONS(2601), 1, + anon_sym_COLON, + ACTIONS(2603), 1, + anon_sym_EQ, + [57809] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2574), 1, + ACTIONS(2605), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, + ACTIONS(2607), 1, anon_sym_STAR, - [57502] = 3, + [57819] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2578), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1334), 1, - sym_field_pattern, - [57512] = 3, + STATE(1317), 1, + sym_symbol_path, + [57829] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2580), 1, - sym_identifier, - ACTIONS(2582), 1, - anon_sym_LPAREN, - [57522] = 2, + ACTIONS(2609), 1, + anon_sym_DASH_GT, + ACTIONS(2611), 1, + anon_sym_EQ_GT, + [57839] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2584), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [57530] = 3, + ACTIONS(2613), 2, + anon_sym__, + sym_identifier, + [57847] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2586), 1, - anon_sym_LBRACE, - ACTIONS(2588), 1, - anon_sym_LT, - [57540] = 2, + ACTIONS(2615), 1, + sym_identifier, + STATE(1706), 1, + sym_field_pattern, + [57857] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2590), 2, - anon_sym_COMMA, - anon_sym_RBRACK, - [57548] = 3, + ACTIONS(2617), 1, + anon_sym_COLON, + ACTIONS(2619), 1, + anon_sym_EQ, + [57867] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1414), 1, - sym__statement_break, - ACTIONS(2592), 1, - anon_sym_DASH_GT, - [57558] = 2, + ACTIONS(2621), 1, + anon_sym_EQ, + ACTIONS(2623), 1, + anon_sym_LT, + [57877] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2493), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [57566] = 2, + ACTIONS(2625), 1, + anon_sym_DASH_GT, + ACTIONS(2627), 1, + anon_sym_EQ_GT, + [57887] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2431), 2, + ACTIONS(2515), 2, anon_sym_COMMA, anon_sym_RPAREN, - [57574] = 2, + [57895] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2343), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [57582] = 2, + ACTIONS(2629), 1, + anon_sym_COLON, + ACTIONS(2631), 1, + anon_sym_EQ, + [57905] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2437), 2, + ACTIONS(2633), 1, anon_sym_RBRACE, + ACTIONS(2635), 1, anon_sym_COMMA, - [57590] = 2, + [57915] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2501), 2, - anon_sym_RBRACE, + ACTIONS(2485), 1, anon_sym_COMMA, - [57598] = 2, + STATE(1233), 1, + aux_sym_tuple_pattern_repeat1, + [57925] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2594), 2, - anon_sym__, + ACTIONS(2326), 1, sym_identifier, - [57606] = 3, + STATE(1345), 1, + sym_field_assignment, + [57935] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2562), 1, + ACTIONS(2615), 1, sym_identifier, - STATE(1745), 1, + STATE(1753), 1, sym_field_pattern, - [57616] = 3, + [57945] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2596), 1, + ACTIONS(2637), 1, anon_sym_LT, - ACTIONS(2598), 1, + ACTIONS(2639), 1, anon_sym_LPAREN, - [57626] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2309), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [57634] = 3, + [57955] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2582), 1, + ACTIONS(2641), 1, + anon_sym_LT, + ACTIONS(2643), 1, anon_sym_LPAREN, - ACTIONS(2600), 1, - sym_identifier, - [57644] = 3, + [57965] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2602), 1, + ACTIONS(1414), 1, + sym__statement_break, + ACTIONS(2645), 1, anon_sym_DASH_GT, - ACTIONS(2604), 1, - anon_sym_EQ_GT, - [57654] = 3, + [57975] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2606), 1, - anon_sym_EQ, - ACTIONS(2608), 1, - anon_sym_LT, - [57664] = 2, + ACTIONS(2647), 1, + anon_sym_COLON, + STATE(908), 1, + sym_signature_ascription, + [57985] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1238), 2, + ACTIONS(1250), 2, sym__statement_break, anon_sym_where, - [57672] = 2, + [57993] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2610), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [57680] = 3, + ACTIONS(1254), 2, + sym__statement_break, + anon_sym_where, + [58001] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, - sym_identifier, - STATE(1159), 1, - sym_symbol_path, - [57690] = 3, + ACTIONS(1260), 2, + sym__statement_break, + anon_sym_where, + [58009] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2448), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1284), 1, - sym_field_assignment, - [57700] = 2, + STATE(1198), 1, + sym_symbol_path, + [58019] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1805), 2, + ACTIONS(1797), 2, anon_sym_LBRACE, anon_sym_EQ, - [57708] = 3, + [58027] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(2649), 1, sym_identifier, - STATE(1317), 1, - sym_symbol_path, - [57718] = 2, + STATE(1273), 1, + sym_named_argument, + [58037] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2614), 2, - anon_sym__, - sym_identifier, - [57726] = 2, + ACTIONS(2262), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [58045] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1260), 2, + ACTIONS(2651), 2, + anon_sym_COMMA, + anon_sym_GT, + [58053] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1238), 2, sym__statement_break, anon_sym_where, - [57734] = 2, + [58061] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1819), 2, - anon_sym_LBRACE, - anon_sym_EQ, - [57742] = 3, + ACTIONS(2653), 1, + anon_sym_DASH_GT, + ACTIONS(2655), 1, + anon_sym_EQ_GT, + [58071] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2616), 1, - anon_sym_LBRACE, - ACTIONS(2618), 1, + ACTIONS(2657), 1, + anon_sym_EQ, + ACTIONS(2659), 1, anon_sym_LT, - [57752] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1406), 1, - sym__statement_break, - ACTIONS(2620), 1, - anon_sym_DASH_GT, - [57762] = 3, + [58081] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2622), 1, + ACTIONS(1772), 1, anon_sym_LBRACE, - ACTIONS(2624), 1, - anon_sym_LT, - [57772] = 3, + ACTIONS(2661), 1, + anon_sym_PLUS, + [58091] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2562), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1665), 1, - sym_field_pattern, - [57782] = 3, + STATE(1305), 1, + sym_symbol_path, + [58101] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2626), 1, - anon_sym_COLON, - ACTIONS(2628), 1, - anon_sym_EQ, - [57792] = 3, + ACTIONS(1242), 2, + sym__statement_break, + anon_sym_where, + [58109] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2630), 1, + ACTIONS(2663), 1, anon_sym_DASH_GT, - ACTIONS(2632), 1, + ACTIONS(2665), 1, anon_sym_EQ_GT, - [57802] = 3, + [58119] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2634), 1, - anon_sym_LBRACE, - ACTIONS(2636), 1, - anon_sym_LT, - [57812] = 3, + ACTIONS(2225), 1, + sym_identifier, + STATE(1281), 1, + sym_import_member, + [58129] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2476), 1, + ACTIONS(2667), 1, sym_identifier, - STATE(1280), 1, - sym_field_declaration, - [57822] = 3, + ACTIONS(2669), 1, + anon_sym_LPAREN, + [58139] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1388), 1, - sym__statement_break, - ACTIONS(2638), 1, + ACTIONS(2671), 1, anon_sym_DASH_GT, - [57832] = 3, + ACTIONS(2673), 1, + anon_sym_EQ_GT, + [58149] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2640), 1, - anon_sym_LBRACE, - ACTIONS(2642), 1, - anon_sym_LT, - [57842] = 3, + ACTIONS(2563), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + [58157] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2644), 1, - anon_sym_DASH_GT, - ACTIONS(2646), 1, - anon_sym_EQ_GT, - [57852] = 3, + ACTIONS(2572), 2, + anon_sym_COMMA, + anon_sym_GT, + [58165] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2648), 1, + ACTIONS(2675), 1, anon_sym_COLON, - ACTIONS(2650), 1, + ACTIONS(2677), 1, anon_sym_EQ, - [57862] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2527), 2, - sym__statement_break, - anon_sym_DOT, - [57870] = 2, + [58175] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2652), 2, - anon_sym_COMMA, - anon_sym_GT, - [57878] = 3, + ACTIONS(2679), 1, + anon_sym_LT, + ACTIONS(2681), 1, + anon_sym_LPAREN, + [58185] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2654), 1, + ACTIONS(2683), 1, anon_sym_EQ, - ACTIONS(2656), 1, + ACTIONS(2685), 1, anon_sym_LT, - [57888] = 2, + [58195] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 2, - sym__statement_break, - anon_sym_where, - [57896] = 3, + ACTIONS(1805), 2, + anon_sym_LBRACE, + anon_sym_EQ, + [58203] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2658), 1, - sym_identifier, - STATE(1219), 1, - sym_qualified_path, - [57906] = 3, + ACTIONS(2687), 1, + anon_sym_EQ, + ACTIONS(2689), 1, + anon_sym_LT, + [58213] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2660), 1, + ACTIONS(2691), 1, anon_sym_LBRACE, - ACTIONS(2662), 1, + ACTIONS(2693), 1, anon_sym_LT, - [57916] = 2, + [58223] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2664), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [57924] = 3, + ACTIONS(2695), 1, + anon_sym_LBRACE, + ACTIONS(2697), 1, + anon_sym_LT, + [58233] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1186), 1, + STATE(1158), 1, sym_symbol_path, - [57934] = 3, + [58243] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1758), 1, - anon_sym_LBRACE, - ACTIONS(2666), 1, - anon_sym_PLUS, - [57944] = 2, + ACTIONS(1388), 1, + sym__statement_break, + ACTIONS(2699), 1, + anon_sym_DASH_GT, + [58253] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2471), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [57952] = 3, + ACTIONS(2196), 1, + sym_identifier, + STATE(1285), 1, + sym_extern_parameter, + [58263] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2668), 1, - anon_sym_COLON, - ACTIONS(2670), 1, - anon_sym_EQ, - [57962] = 3, + ACTIONS(2701), 1, + anon_sym_LBRACE, + ACTIONS(2703), 1, + anon_sym_LT, + [58273] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, - sym_identifier, - STATE(1196), 1, - sym_symbol_path, - [57972] = 3, + ACTIONS(1392), 2, + sym__statement_break, + anon_sym_where, + [58281] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2672), 1, - anon_sym_LT, - ACTIONS(2674), 1, - anon_sym_LPAREN, - [57982] = 3, + ACTIONS(2324), 1, + sym_identifier, + STATE(1286), 1, + sym_field_declaration, + [58291] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2676), 1, - sym_identifier, - STATE(995), 1, - sym_qualified_path, - [57992] = 3, + ACTIONS(2705), 1, + anon_sym_LBRACE, + ACTIONS(2707), 1, + anon_sym_LT, + [58301] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, - sym_identifier, - STATE(1203), 1, - sym_symbol_path, - [58002] = 3, + ACTIONS(2532), 2, + sym__statement_break, + anon_sym_DOT, + [58309] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, - sym_identifier, - STATE(1206), 1, - sym_symbol_path, - [58012] = 3, + ACTIONS(2709), 1, + anon_sym_LBRACE, + ACTIONS(2711), 1, + anon_sym_LT, + [58319] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(2615), 1, sym_identifier, - STATE(1212), 1, - sym_symbol_path, - [58022] = 3, + STATE(1451), 1, + sym_field_pattern, + [58329] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(2713), 1, sym_identifier, - STATE(1350), 1, - sym_symbol_path, - [58032] = 3, + STATE(1130), 1, + sym_qualified_path, + [58339] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2678), 1, + ACTIONS(2715), 1, + anon_sym_LBRACE, + ACTIONS(2717), 1, anon_sym_LT, - ACTIONS(2680), 1, - anon_sym_LPAREN, - [58042] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2612), 1, - sym_identifier, - STATE(1211), 1, - sym_symbol_path, - [58052] = 2, + [58349] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2469), 2, + ACTIONS(2315), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_GT, - [58060] = 3, + [58357] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2682), 1, - anon_sym_EQ, - ACTIONS(2684), 1, + ACTIONS(2719), 1, + anon_sym_LBRACE, + ACTIONS(2721), 1, anon_sym_LT, - [58070] = 2, + [58367] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2546), 2, + ACTIONS(2346), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_RPAREN, - [58078] = 3, + [58375] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1748), 1, + ACTIONS(2723), 1, anon_sym_LBRACE, - ACTIONS(1754), 1, - anon_sym_LPAREN, - [58088] = 3, + ACTIONS(2725), 1, + anon_sym_LT, + [58385] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2686), 1, - sym_identifier, - STATE(1025), 1, - sym_qualified_path, - [58098] = 3, + ACTIONS(2727), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [58393] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2688), 1, - anon_sym_RBRACE, - ACTIONS(2690), 1, - anon_sym_COMMA, - [58108] = 3, + ACTIONS(2597), 1, + sym_identifier, + STATE(1176), 1, + sym_symbol_path, + [58403] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2729), 2, anon_sym_COMMA, - STATE(1151), 1, - aux_sym_tuple_pattern_repeat1, - [58118] = 3, + anon_sym_RBRACK, + [58411] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2692), 1, - anon_sym_EQ, - ACTIONS(2694), 1, - anon_sym_LT, - [58128] = 3, + ACTIONS(2597), 1, + sym_identifier, + STATE(1173), 1, + sym_symbol_path, + [58421] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2696), 1, + ACTIONS(2731), 1, anon_sym_LT, - ACTIONS(2698), 1, + ACTIONS(2733), 1, anon_sym_LPAREN, - [58138] = 3, + [58431] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2700), 1, + ACTIONS(2735), 1, sym_identifier, - STATE(1277), 1, - sym_named_argument, - [58148] = 3, + STATE(1043), 1, + sym_qualified_path, + [58441] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2702), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(833), 1, + STATE(1183), 1, sym_symbol_path, - [58158] = 3, + [58451] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2612), 1, + ACTIONS(2597), 1, sym_identifier, - STATE(1144), 1, + STATE(1186), 1, sym_symbol_path, - [58168] = 3, + [58461] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2704), 1, - anon_sym_DASH_GT, - ACTIONS(2706), 1, - anon_sym_EQ_GT, - [58178] = 3, + ACTIONS(2737), 1, + sym_identifier, + STATE(1044), 1, + sym_qualified_path, + [58471] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2708), 1, - anon_sym_LBRACE, - ACTIONS(2710), 1, + ACTIONS(2739), 1, anon_sym_LT, - [58188] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2712), 2, - anon_sym_COMMA, - anon_sym_GT, - [58196] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2069), 2, - anon_sym_LBRACE, - anon_sym_SEMI, - [58204] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1728), 1, - sym_static_stage, - ACTIONS(1730), 1, - anon_sym_effect, - [58214] = 2, + ACTIONS(2741), 1, + anon_sym_LPAREN, + [58481] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1264), 2, - sym__statement_break, - anon_sym_where, - [58222] = 3, + ACTIONS(2597), 1, + sym_identifier, + STATE(1196), 1, + sym_symbol_path, + [58491] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2147), 1, + ACTIONS(2743), 1, sym_identifier, - STATE(1318), 1, - sym_import_member, - [58232] = 3, + STATE(1056), 1, + sym_qualified_path, + [58501] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2714), 1, + ACTIONS(2745), 1, anon_sym_DASH_GT, - ACTIONS(2716), 1, + ACTIONS(2747), 1, anon_sym_EQ_GT, - [58242] = 3, + [58511] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2718), 1, - sym_identifier, - STATE(1252), 1, - sym_qualified_path, - [58252] = 3, + ACTIONS(2749), 2, + anon_sym_COMMA, + anon_sym_GT, + [58519] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2720), 1, - anon_sym_COLON, - STATE(922), 1, - sym_signature_ascription, - [58262] = 3, + ACTIONS(2751), 2, + anon_sym_COMMA, + anon_sym_GT, + [58527] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2562), 1, + ACTIONS(2615), 1, sym_identifier, - STATE(1360), 1, + STATE(1736), 1, sym_field_pattern, - [58272] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2722), 1, - anon_sym_COLON, - ACTIONS(2724), 1, - anon_sym_EQ, - [58282] = 2, + [58537] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1246), 2, - sym__statement_break, - anon_sym_where, - [58290] = 3, + ACTIONS(2085), 2, + anon_sym_LBRACE, + anon_sym_SEMI, + [58545] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2726), 1, + ACTIONS(2753), 1, sym_identifier, - STATE(1258), 1, + STATE(1260), 1, sym_qualified_path, - [58300] = 3, + [58555] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, - sym__statement_break, - ACTIONS(2728), 1, - anon_sym_DASH_GT, - [58310] = 3, + ACTIONS(2669), 1, + anon_sym_LPAREN, + ACTIONS(2755), 1, + sym_identifier, + [58565] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2562), 1, + ACTIONS(2615), 1, sym_identifier, - STATE(1737), 1, + STATE(1747), 1, sym_field_pattern, - [58320] = 3, + [58575] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 1, - sym_identifier, - STATE(1276), 1, - sym_extern_parameter, - [58330] = 3, + ACTIONS(1716), 1, + sym_static_stage, + ACTIONS(1718), 1, + anon_sym_effect, + [58585] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2730), 1, - anon_sym_LT, - ACTIONS(2732), 1, - anon_sym_LPAREN, - [58340] = 2, + ACTIONS(1746), 1, + anon_sym_RPAREN, + [58592] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2404), 2, - anon_sym_COMMA, - anon_sym_RBRACK, - [58348] = 2, + ACTIONS(2757), 1, + anon_sym_COLON, + [58599] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2734), 1, + ACTIONS(2759), 1, anon_sym_RBRACE, - [58355] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2736), 1, - anon_sym_type, - [58362] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2738), 1, - anon_sym_LPAREN2, - [58369] = 2, + [58606] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2740), 1, + ACTIONS(2761), 1, anon_sym_RBRACE, - [58376] = 2, + [58613] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1526), 1, + ACTIONS(1436), 1, sym__statement_break, - [58383] = 2, + [58620] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2742), 1, - anon_sym_GT, - [58390] = 2, + ACTIONS(2763), 1, + anon_sym_EQ, + [58627] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2744), 1, + ACTIONS(2765), 1, anon_sym_EQ, - [58397] = 2, + [58634] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2746), 1, - anon_sym_COLON, - [58404] = 2, + ACTIONS(1408), 1, + sym__statement_break, + [58641] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2748), 1, - anon_sym_RPAREN, - [58411] = 2, + ACTIONS(2767), 1, + sym_identifier, + [58648] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2750), 1, - anon_sym_COLON, - [58418] = 2, + ACTIONS(2769), 1, + sym__statement_break, + [58655] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2752), 1, - anon_sym_RBRACE, - [58425] = 2, + ACTIONS(2771), 1, + anon_sym_LPAREN, + [58662] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2754), 1, - anon_sym_LPAREN, - [58432] = 2, + ACTIONS(2773), 1, + anon_sym_LBRACE, + [58669] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2775), 1, + anon_sym_RPAREN, + [58676] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1488), 1, + ACTIONS(1458), 1, sym__statement_break, - [58439] = 2, + [58683] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2756), 1, - anon_sym_LPAREN, - [58446] = 2, + ACTIONS(2777), 1, + sym_identifier, + [58690] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2758), 1, - anon_sym_RPAREN, - [58453] = 2, + ACTIONS(2779), 1, + anon_sym_LPAREN, + [58697] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2760), 1, - anon_sym_DASH_GT, - [58460] = 2, + ACTIONS(2781), 1, + anon_sym_GT, + [58704] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1528), 1, + ACTIONS(1540), 1, sym__statement_break, - [58467] = 2, + [58711] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1712), 1, + ACTIONS(2783), 1, anon_sym_RPAREN, - [58474] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1444), 1, - sym__statement_break, - [58481] = 2, + [58718] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2762), 1, + ACTIONS(2785), 1, anon_sym_DASH_GT, - [58488] = 2, + [58725] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2764), 1, + ACTIONS(2787), 1, anon_sym_RBRACE, - [58495] = 2, + [58732] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2766), 1, + ACTIONS(2789), 1, anon_sym_RPAREN, - [58502] = 2, + [58739] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2768), 1, + ACTIONS(2791), 1, anon_sym_RPAREN, - [58509] = 2, + [58746] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2770), 1, - anon_sym_LPAREN, - [58516] = 2, + ACTIONS(2793), 1, + anon_sym_EQ_GT, + [58753] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1530), 1, - sym__statement_break, - [58523] = 2, + ACTIONS(2795), 1, + anon_sym_GT, + [58760] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2772), 1, - anon_sym_LPAREN, - [58530] = 2, + ACTIONS(2797), 1, + anon_sym_GT, + [58767] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2774), 1, + ACTIONS(2799), 1, anon_sym_EQ_GT, - [58537] = 2, + [58774] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2776), 1, - anon_sym_RPAREN, - [58544] = 2, + ACTIONS(1410), 1, + sym__statement_break, + [58781] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1448), 1, - sym__statement_break, - [58551] = 2, + ACTIONS(2801), 1, + anon_sym_LBRACE, + [58788] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1532), 1, - sym__statement_break, - [58558] = 2, + ACTIONS(2803), 1, + anon_sym_GT, + [58795] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1432), 1, - sym__statement_break, - [58565] = 2, + ACTIONS(2805), 1, + sym_identifier, + [58802] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2778), 1, + ACTIONS(2807), 1, anon_sym_RPAREN, - [58572] = 2, + [58809] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2780), 1, + ACTIONS(2809), 1, anon_sym_RBRACE, - [58579] = 2, + [58816] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2782), 1, + ACTIONS(2811), 1, sym_identifier, - [58586] = 2, + [58823] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2784), 1, - anon_sym_EQ, - [58593] = 2, + ACTIONS(2813), 1, + anon_sym_fn, + [58830] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2786), 1, + ACTIONS(2815), 1, anon_sym_EQ, - [58600] = 2, + [58837] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1366), 1, + ACTIONS(1552), 1, sym__statement_break, - [58607] = 2, + [58844] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1536), 1, + ACTIONS(1442), 1, sym__statement_break, - [58614] = 2, + [58851] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2788), 1, - sym_identifier, - [58621] = 2, + ACTIONS(2817), 1, + anon_sym_extra, + [58858] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2790), 1, - anon_sym_GT, - [58628] = 2, + ACTIONS(1510), 1, + sym__statement_break, + [58865] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1538), 1, + ACTIONS(1460), 1, sym__statement_break, - [58635] = 2, + [58872] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1410), 1, + ACTIONS(1514), 1, sym__statement_break, - [58642] = 2, + [58879] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2792), 1, + ACTIONS(2819), 1, anon_sym_extra, - [58649] = 2, + [58886] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2794), 1, - anon_sym_LBRACE, - [58656] = 2, + ACTIONS(2821), 1, + anon_sym_COLON, + [58893] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2796), 1, + ACTIONS(2823), 1, anon_sym_DASH_GT, - [58663] = 2, + [58900] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2798), 1, + ACTIONS(2825), 1, anon_sym_GT, - [58670] = 2, + [58907] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2800), 1, + ACTIONS(2827), 1, anon_sym_RBRACK, - [58677] = 2, + [58914] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2802), 1, + ACTIONS(2829), 1, anon_sym_EQ, - [58684] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1450), 1, - sym__statement_break, - [58691] = 2, + [58921] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2804), 1, - anon_sym_EQ_GT, - [58698] = 2, + ACTIONS(2831), 1, + sym_identifier, + [58928] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1490), 1, + ACTIONS(1462), 1, sym__statement_break, - [58705] = 2, + [58935] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1452), 1, + ACTIONS(1444), 1, sym__statement_break, - [58712] = 2, + [58942] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1454), 1, + ACTIONS(1446), 1, sym__statement_break, - [58719] = 2, + [58949] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2806), 1, - anon_sym_PIPE, - [58726] = 2, + ACTIONS(2833), 1, + anon_sym_DASH_GT, + [58956] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1540), 1, + ACTIONS(1418), 1, sym__statement_break, - [58733] = 2, + [58963] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1456), 1, - sym__statement_break, - [58740] = 2, + ACTIONS(2835), 1, + anon_sym_LBRACE, + [58970] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2808), 1, - anon_sym_EQ_GT, - [58747] = 2, + ACTIONS(2837), 1, + sym_identifier, + [58977] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2810), 1, - anon_sym_extra, - [58754] = 2, + ACTIONS(2839), 1, + anon_sym_EQ_GT, + [58984] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1498), 1, + ACTIONS(1474), 1, sym__statement_break, - [58761] = 2, + [58991] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2812), 1, - sym_identifier, - [58768] = 2, + ACTIONS(1476), 1, + sym__statement_break, + [58998] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1542), 1, + ACTIONS(1448), 1, sym__statement_break, - [58775] = 2, + [59005] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2841), 1, + anon_sym_RPAREN, + [59012] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2814), 1, + ACTIONS(2843), 1, anon_sym_RBRACE, - [58782] = 2, + [59019] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2816), 1, + ACTIONS(2845), 1, anon_sym_RPAREN, - [58789] = 2, + [59026] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2818), 1, - anon_sym_COLON, - [58796] = 2, + ACTIONS(1440), 1, + sym__statement_break, + [59033] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2820), 1, - anon_sym_RBRACE, - [58803] = 2, + ACTIONS(1438), 1, + sym__statement_break, + [59040] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2822), 1, + ACTIONS(2847), 1, anon_sym_RPAREN, - [58810] = 2, + [59047] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2824), 1, - anon_sym_GT, - [58817] = 2, + ACTIONS(1478), 1, + sym__statement_break, + [59054] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2826), 1, - anon_sym_RPAREN, - [58824] = 2, + ACTIONS(2849), 1, + anon_sym_LPAREN, + [59061] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2828), 1, + ACTIONS(2851), 1, anon_sym_DASH_GT, - [58831] = 2, + [59068] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1544), 1, - sym__statement_break, - [58838] = 2, + ACTIONS(2853), 1, + anon_sym_DASH_GT, + [59075] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2830), 1, - ts_builtin_sym_end, - [58845] = 2, + ACTIONS(2855), 1, + anon_sym_RPAREN, + [59082] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2832), 1, - sym_identifier, - [58852] = 2, + ACTIONS(2857), 1, + anon_sym_EQ, + [59089] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2834), 1, + ACTIONS(2859), 1, anon_sym_RPAREN, - [58859] = 2, + [59096] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2836), 1, + ACTIONS(2861), 1, anon_sym_EQ, - [58866] = 2, + [59103] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1458), 1, + ACTIONS(1480), 1, sym__statement_break, - [58873] = 2, + [59110] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2838), 1, - anon_sym_RBRACK, - [58880] = 2, + ACTIONS(2863), 1, + anon_sym_GT, + [59117] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1508), 1, - sym__statement_break, - [58887] = 2, + ACTIONS(2865), 1, + anon_sym_RBRACK, + [59124] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1546), 1, - sym__statement_break, - [58894] = 2, + ACTIONS(2867), 1, + sym_identifier, + [59131] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2840), 1, - anon_sym_GT, - [58901] = 2, + ACTIONS(1484), 1, + sym__statement_break, + [59138] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2842), 1, - anon_sym_DASH_GT, - [58908] = 2, + ACTIONS(1384), 1, + sym__statement_break, + [59145] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2844), 1, + ACTIONS(2869), 1, anon_sym_RBRACK, - [58915] = 2, + [59152] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1548), 1, - sym__statement_break, - [58922] = 2, + ACTIONS(2871), 1, + anon_sym_RBRACE, + [59159] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2846), 1, - anon_sym_RPAREN, - [58929] = 2, + ACTIONS(2873), 1, + anon_sym_LPAREN, + [59166] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2848), 1, - anon_sym_RPAREN, - [58936] = 2, + ACTIONS(2875), 1, + anon_sym_LBRACE, + [59173] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2850), 1, - anon_sym_GT, - [58943] = 2, + ACTIONS(2877), 1, + sym__statement_break, + [59180] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2852), 1, + ACTIONS(2879), 1, anon_sym_RPAREN, - [58950] = 2, + [59187] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1460), 1, + ACTIONS(1486), 1, sym__statement_break, - [58957] = 2, + [59194] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1462), 1, + ACTIONS(2881), 1, sym__statement_break, - [58964] = 2, + [59201] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2854), 1, - anon_sym_RBRACK, - [58971] = 2, + ACTIONS(1490), 1, + sym__statement_break, + [59208] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1023), 1, - anon_sym_RPAREN, - [58978] = 2, + ACTIONS(2883), 1, + anon_sym_module, + [59215] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1554), 1, + ACTIONS(1492), 1, sym__statement_break, - [58985] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2632), 1, - anon_sym_EQ_GT, - [58992] = 2, + [59222] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2856), 1, - sym_identifier, - [58999] = 2, + ACTIONS(1420), 1, + sym__statement_break, + [59229] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2858), 1, - anon_sym_fn, - [59006] = 2, + ACTIONS(2885), 1, + anon_sym_LPAREN, + [59236] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2860), 1, - anon_sym_QMARK, - [59013] = 2, + ACTIONS(2887), 1, + anon_sym_GT, + [59243] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2862), 1, + ACTIONS(2889), 1, sym_identifier, - [59020] = 2, + [59250] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2864), 1, - anon_sym_effect, - [59027] = 2, + ACTIONS(2891), 1, + sym_identifier, + [59257] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2866), 1, + ACTIONS(2893), 1, sym_identifier, - [59034] = 2, + [59264] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2868), 1, - anon_sym_LPAREN2, - [59041] = 2, + ACTIONS(2895), 1, + anon_sym_LBRACE, + [59271] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2870), 1, - anon_sym_RBRACE, - [59048] = 2, + ACTIONS(1528), 1, + sym__statement_break, + [59278] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2872), 1, + ACTIONS(2897), 1, anon_sym_RPAREN, - [59055] = 2, + [59285] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1378), 1, - sym__statement_break, - [59062] = 2, + ACTIONS(2899), 1, + anon_sym_EQ_GT, + [59292] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2874), 1, - sym__statement_break, - [59069] = 2, + ACTIONS(2901), 1, + sym_identifier, + [59299] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2876), 1, - anon_sym_EQ, - [59076] = 2, + ACTIONS(1422), 1, + sym__statement_break, + [59306] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2878), 1, - sym__statement_break, - [59083] = 2, + ACTIONS(2903), 1, + anon_sym_COLON, + [59313] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2880), 1, - anon_sym_GT, - [59090] = 2, + ACTIONS(2905), 1, + anon_sym_EQ, + [59320] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2882), 1, - anon_sym_module, - [59097] = 2, + ACTIONS(2907), 1, + anon_sym_RBRACK, + [59327] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2884), 1, + ACTIONS(2909), 1, anon_sym_RPAREN, - [59104] = 2, + [59334] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2886), 1, - sym_identifier, - [59111] = 2, + ACTIONS(2911), 1, + anon_sym_LPAREN, + [59341] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2888), 1, - anon_sym_COLON, - [59118] = 2, + ACTIONS(2913), 1, + anon_sym_GT, + [59348] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2890), 1, - anon_sym_GT, - [59125] = 2, + ACTIONS(1450), 1, + sym__statement_break, + [59355] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2892), 1, - sym_identifier, - [59132] = 2, + ACTIONS(2915), 1, + anon_sym_RPAREN, + [59362] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2894), 1, - anon_sym_COLON, - [59139] = 2, + ACTIONS(2917), 1, + anon_sym_LPAREN, + [59369] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2896), 1, - anon_sym_COLON, - [59146] = 2, + ACTIONS(2919), 1, + anon_sym_RBRACK, + [59376] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2898), 1, - anon_sym_LPAREN, - [59153] = 2, + ACTIONS(2921), 1, + anon_sym_GT, + [59383] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1412), 1, - sym__statement_break, - [59160] = 2, + ACTIONS(2923), 1, + anon_sym_GT, + [59390] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1396), 1, - sym__statement_break, - [59167] = 2, + ACTIONS(2925), 1, + anon_sym_LBRACE, + [59397] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2900), 1, + ACTIONS(1504), 1, sym__statement_break, - [59174] = 2, + [59404] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2902), 1, - anon_sym_GT, - [59181] = 2, + ACTIONS(2927), 1, + anon_sym_RPAREN, + [59411] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2904), 1, - anon_sym_effect, - [59188] = 2, + ACTIONS(1386), 1, + sym__statement_break, + [59418] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2906), 1, - anon_sym_LBRACE, - [59195] = 2, + ACTIONS(2929), 1, + sym_identifier, + [59425] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2908), 1, - anon_sym_RBRACK, - [59202] = 2, + ACTIONS(1498), 1, + sym__statement_break, + [59432] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2931), 1, + anon_sym_GT, + [59439] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2910), 1, + ACTIONS(2933), 1, anon_sym_RBRACE, - [59209] = 2, + [59446] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2912), 1, + ACTIONS(2935), 1, sym_identifier, - [59216] = 2, + [59453] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1520), 1, - sym__statement_break, - [59223] = 2, + ACTIONS(2937), 1, + anon_sym_LBRACE, + [59460] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2914), 1, - anon_sym_GT, - [59230] = 2, + ACTIONS(1456), 1, + sym__statement_break, + [59467] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2916), 1, + ACTIONS(2939), 1, anon_sym_EQ_GT, - [59237] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2918), 1, - anon_sym_LBRACE, - [59244] = 2, + [59474] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1522), 1, + ACTIONS(1500), 1, sym__statement_break, - [59251] = 2, + [59481] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2920), 1, - sym_identifier, - [59258] = 2, + ACTIONS(1502), 1, + sym__statement_break, + [59488] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2922), 1, + ACTIONS(2941), 1, sym_identifier, - [59265] = 2, + [59495] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2924), 1, + ACTIONS(2943), 1, sym_identifier, - [59272] = 2, + [59502] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2926), 1, + ACTIONS(2945), 1, sym_identifier, - [59279] = 2, + [59509] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2928), 1, - anon_sym_RPAREN, - [59286] = 2, + ACTIONS(2947), 1, + anon_sym_COLON, + [59516] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(1464), 1, sym__statement_break, - [59293] = 2, + [59523] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2930), 1, + ACTIONS(2949), 1, + anon_sym_fn, + [59530] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1370), 1, sym__statement_break, - [59300] = 2, + [59537] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2568), 1, + ACTIONS(2665), 1, anon_sym_EQ_GT, - [59307] = 2, + [59544] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2932), 1, - sym_identifier, - [59314] = 2, + ACTIONS(1424), 1, + sym__statement_break, + [59551] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2934), 1, - anon_sym_GT, - [59321] = 2, + ACTIONS(2951), 1, + anon_sym_type, + [59558] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2936), 1, - anon_sym_RBRACE, - [59328] = 2, + ACTIONS(1506), 1, + sym__statement_break, + [59565] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2938), 1, - anon_sym_RPAREN, - [59335] = 2, + ACTIONS(2953), 1, + sym_identifier, + [59572] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2940), 1, - anon_sym_LBRACE, - [59342] = 2, + ACTIONS(2955), 1, + sym__statement_break, + [59579] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2942), 1, - anon_sym_GT, - [59349] = 2, + ACTIONS(2957), 1, + anon_sym_COLON, + [59586] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2944), 1, - anon_sym_GT, - [59356] = 2, + ACTIONS(1508), 1, + sym__statement_break, + [59593] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2946), 1, + ACTIONS(2959), 1, anon_sym_RBRACE, - [59363] = 2, + [59600] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2948), 1, - anon_sym_EQ_GT, - [59370] = 2, + ACTIONS(2961), 1, + anon_sym_GT, + [59607] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2950), 1, - sym__statement_break, - [59377] = 2, + ACTIONS(1857), 1, + anon_sym_COLON, + [59614] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2952), 1, - anon_sym_EQ_GT, - [59384] = 2, + ACTIONS(2963), 1, + anon_sym_LPAREN, + [59621] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2954), 1, - anon_sym_RBRACE, - [59391] = 2, + ACTIONS(1572), 1, + sym__statement_break, + [59628] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2956), 1, + ACTIONS(2965), 1, anon_sym_RBRACE, - [59398] = 2, + [59635] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2958), 1, - sym_identifier, - [59405] = 2, + ACTIONS(2967), 1, + anon_sym_COLON, + [59642] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1534), 1, - sym__statement_break, - [59412] = 2, + ACTIONS(2969), 1, + anon_sym_EQ_GT, + [59649] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2960), 1, + ACTIONS(1452), 1, sym__statement_break, - [59419] = 2, + [59656] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2962), 1, + ACTIONS(2971), 1, anon_sym_RBRACE, - [59426] = 2, + [59663] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2964), 1, + ACTIONS(2973), 1, anon_sym_DASH_GT, - [59433] = 2, + [59670] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2966), 1, + ACTIONS(2975), 1, anon_sym_RBRACE, - [59440] = 2, + [59677] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2968), 1, + ACTIONS(2977), 1, anon_sym_RPAREN, - [59447] = 2, + [59684] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2970), 1, + ACTIONS(2979), 1, anon_sym_RPAREN, - [59454] = 2, + [59691] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2972), 1, + ACTIONS(2981), 1, anon_sym_EQ_GT, - [59461] = 2, + [59698] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2974), 1, + ACTIONS(2983), 1, anon_sym_EQ_GT, - [59468] = 2, + [59705] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1466), 1, + ACTIONS(1454), 1, sym__statement_break, - [59475] = 2, + [59712] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(568), 1, + ACTIONS(1512), 1, sym__statement_break, - [59482] = 2, + [59719] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2976), 1, + ACTIONS(2985), 1, anon_sym_DASH_GT, - [59489] = 2, + [59726] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2978), 1, + ACTIONS(2987), 1, anon_sym_GT, - [59496] = 2, + [59733] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2980), 1, + ACTIONS(2989), 1, anon_sym_RBRACK, - [59503] = 2, + [59740] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2982), 1, + ACTIONS(2991), 1, anon_sym_EQ_GT, - [59510] = 2, + [59747] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2984), 1, - sym__statement_break, - [59517] = 2, + ACTIONS(2993), 1, + anon_sym_DASH_GT, + [59754] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2986), 1, + ACTIONS(2995), 1, anon_sym_RPAREN, - [59524] = 2, + [59761] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2988), 1, - sym_identifier, - [59531] = 2, + ACTIONS(1466), 1, + sym__statement_break, + [59768] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2990), 1, + ACTIONS(2997), 1, anon_sym_DASH_GT, - [59538] = 2, + [59775] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2992), 1, - anon_sym_LPAREN, - [59545] = 2, + ACTIONS(1426), 1, + sym__statement_break, + [59782] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2994), 1, + ACTIONS(2999), 1, anon_sym_RPAREN, - [59552] = 2, + [59789] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1468), 1, - sym__statement_break, - [59559] = 2, + ACTIONS(3001), 1, + sym_identifier, + [59796] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2996), 1, - sym_identifier, - [59566] = 2, + ACTIONS(3003), 1, + anon_sym_LPAREN, + [59803] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2998), 1, + ACTIONS(3005), 1, sym_identifier, - [59573] = 2, + [59810] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3000), 1, - anon_sym_LPAREN, - [59580] = 2, + ACTIONS(3007), 1, + anon_sym_COLON, + [59817] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1564), 1, - sym__statement_break, - [59587] = 2, + ACTIONS(3009), 1, + sym_identifier, + [59824] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3002), 1, + ACTIONS(3011), 1, sym_identifier, - [59594] = 2, + [59831] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1418), 1, - sym__statement_break, - [59601] = 2, + ACTIONS(3013), 1, + anon_sym_RBRACE, + [59838] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3004), 1, + ACTIONS(3015), 1, sym_identifier, - [59608] = 2, + [59845] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3006), 1, + ACTIONS(3017), 1, sym_identifier, - [59615] = 2, + [59852] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3008), 1, + ACTIONS(3019), 1, sym_identifier, - [59622] = 2, + [59859] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3010), 1, + ACTIONS(3021), 1, sym_identifier, - [59629] = 2, + [59866] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3012), 1, - anon_sym_LBRACE, - [59636] = 2, + ACTIONS(3023), 1, + sym_identifier, + [59873] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3014), 1, - anon_sym_EQ_GT, - [59643] = 2, + ACTIONS(3025), 1, + sym_identifier, + [59880] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1472), 1, - sym__statement_break, - [59650] = 2, + ACTIONS(3027), 1, + anon_sym_RBRACE, + [59887] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3016), 1, + ACTIONS(3029), 1, anon_sym_LPAREN, - [59657] = 2, + [59894] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1474), 1, + ACTIONS(1494), 1, sym__statement_break, - [59664] = 2, + [59901] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2582), 1, + ACTIONS(2669), 1, anon_sym_LPAREN, - [59671] = 2, + [59908] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3018), 1, - anon_sym_LPAREN, - [59678] = 2, + ACTIONS(1366), 1, + sym__statement_break, + [59915] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3020), 1, + ACTIONS(3031), 1, anon_sym_PIPE, - [59685] = 2, + [59922] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1476), 1, - sym__statement_break, - [59692] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3022), 1, + ACTIONS(3033), 1, sym_identifier, - [59699] = 2, + [59929] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1566), 1, - sym__statement_break, - [59706] = 2, + ACTIONS(3035), 1, + anon_sym_COLON, + [59936] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3024), 1, + ACTIONS(3037), 1, anon_sym_LBRACE, - [59713] = 2, + [59943] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3026), 1, - sym_identifier, - [59720] = 2, + ACTIONS(3039), 1, + anon_sym_PIPE, + [59950] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1478), 1, + ACTIONS(1496), 1, sym__statement_break, - [59727] = 2, + [59957] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3028), 1, - anon_sym_LPAREN, - [59734] = 2, + ACTIONS(1516), 1, + sym__statement_break, + [59964] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(600), 1, - sym__statement_break, - [59741] = 2, + ACTIONS(3041), 1, + anon_sym_RPAREN, + [59971] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(990), 1, + anon_sym_RPAREN, + [59978] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3030), 1, + ACTIONS(3043), 1, anon_sym_LBRACE, - [59748] = 2, + [59985] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3032), 1, - anon_sym_EQ_GT, - [59755] = 2, + ACTIONS(3045), 1, + sym_identifier, + [59992] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1434), 1, + ACTIONS(1518), 1, sym__statement_break, - [59762] = 2, + [59999] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3034), 1, + ACTIONS(3047), 1, anon_sym_LPAREN, - [59769] = 2, + [60006] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1480), 1, - sym__statement_break, - [59776] = 2, + ACTIONS(3049), 1, + sym_identifier, + [60013] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3036), 1, + ACTIONS(3051), 1, anon_sym_LPAREN2, - [59783] = 2, + [60020] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3038), 1, + ACTIONS(3053), 1, anon_sym_LBRACE, - [59790] = 2, + [60027] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3040), 1, + ACTIONS(3055), 1, sym_identifier, - [59797] = 2, + [60034] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3042), 1, + ACTIONS(3057), 1, sym_identifier, - [59804] = 2, + [60041] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3044), 1, - anon_sym_LPAREN, - [59811] = 2, + ACTIONS(1520), 1, + sym__statement_break, + [60048] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3046), 1, + ACTIONS(3059), 1, anon_sym_RPAREN, - [59818] = 2, + [60055] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3048), 1, - anon_sym_COLON, - [59825] = 2, + ACTIONS(3061), 1, + sym_identifier, + [60062] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3050), 1, + ACTIONS(3063), 1, anon_sym_LPAREN, - [59832] = 2, + [60069] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3052), 1, - anon_sym_RPAREN, - [59839] = 2, + ACTIONS(3065), 1, + sym_identifier, + [60076] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3054), 1, - anon_sym_RBRACE, - [59846] = 2, + ACTIONS(1522), 1, + sym__statement_break, + [60083] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1482), 1, + ACTIONS(1524), 1, sym__statement_break, - [59853] = 2, + [60090] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3056), 1, - anon_sym_RPAREN, - [59860] = 2, + ACTIONS(1428), 1, + sym__statement_break, + [60097] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3058), 1, + ACTIONS(3067), 1, sym_identifier, - [59867] = 2, + [60104] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3060), 1, + ACTIONS(3069), 1, anon_sym_LBRACE, - [59874] = 2, + [60111] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3062), 1, - sym_identifier, - [59881] = 2, + ACTIONS(1430), 1, + sym__statement_break, + [60118] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1486), 1, - sym__statement_break, - [59888] = 2, + ACTIONS(3071), 1, + anon_sym_else, + [60125] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1420), 1, - sym__statement_break, - [59895] = 2, + ACTIONS(3073), 1, + anon_sym_RBRACE, + [60132] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1436), 1, - sym__statement_break, - [59902] = 2, + ACTIONS(3075), 1, + anon_sym_GT, + [60139] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3064), 1, + ACTIONS(3077), 1, anon_sym_LBRACE, - [59909] = 2, + [60146] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3066), 1, - anon_sym_COLON, - [59916] = 2, + ACTIONS(1530), 1, + sym__statement_break, + [60153] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3068), 1, + ACTIONS(3079), 1, anon_sym_RPAREN, - [59923] = 2, + [60160] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3070), 1, + ACTIONS(3081), 1, anon_sym_RBRACE, - [59930] = 2, + [60167] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3072), 1, + ACTIONS(3083), 1, anon_sym_GT, - [59937] = 2, + [60174] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3074), 1, - anon_sym_module, - [59944] = 2, + ACTIONS(3085), 1, + anon_sym_RPAREN, + [60181] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3076), 1, - sym__statement_break, - [59951] = 2, + ACTIONS(3087), 1, + anon_sym_QMARK, + [60188] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3078), 1, + ACTIONS(3089), 1, anon_sym_LPAREN, - [59958] = 2, + [60195] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3080), 1, + ACTIONS(3091), 1, anon_sym_LBRACE, - [59965] = 2, + [60202] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3082), 1, + ACTIONS(1526), 1, sym__statement_break, - [59972] = 2, + [60209] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1716), 1, + ACTIONS(1740), 1, anon_sym_RPAREN, - [59979] = 2, + [60216] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1404), 1, + ACTIONS(1532), 1, sym__statement_break, - [59986] = 2, + [60223] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3084), 1, - anon_sym_LBRACE, - [59993] = 2, + ACTIONS(3093), 1, + anon_sym_LPAREN, + [60230] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3086), 1, + ACTIONS(3095), 1, sym_identifier, - [60000] = 2, + [60237] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1422), 1, - sym__statement_break, - [60007] = 2, + ACTIONS(3097), 1, + anon_sym_RPAREN, + [60244] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3088), 1, + ACTIONS(3099), 1, anon_sym_LPAREN, - [60014] = 2, + [60251] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1470), 1, - sym__statement_break, - [60021] = 2, + ACTIONS(3101), 1, + anon_sym_DOT, + [60258] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3090), 1, - anon_sym_EQ_GT, - [60028] = 2, + ACTIONS(3103), 1, + sym__statement_break, + [60265] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3092), 1, + ACTIONS(3105), 1, anon_sym_LBRACE, - [60035] = 2, + [60272] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3094), 1, - anon_sym_RBRACK, - [60042] = 2, + ACTIONS(3107), 1, + sym__statement_break, + [60279] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3096), 1, - anon_sym_fn, - [60049] = 2, + ACTIONS(2655), 1, + anon_sym_EQ_GT, + [60286] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3098), 1, - anon_sym_LPAREN, - [60056] = 2, + ACTIONS(1402), 1, + sym__statement_break, + [60293] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3100), 1, - anon_sym_EQ, - [60063] = 2, + ACTIONS(3109), 1, + anon_sym_LBRACE, + [60300] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3102), 1, + ACTIONS(3111), 1, anon_sym_LBRACE, - [60070] = 2, + [60307] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3104), 1, + ACTIONS(3113), 1, anon_sym_else, - [60077] = 2, + [60314] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3106), 1, + ACTIONS(3115), 1, anon_sym_LPAREN, - [60084] = 2, + [60321] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3108), 1, + ACTIONS(3117), 1, anon_sym_RPAREN, - [60091] = 2, + [60328] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3110), 1, - anon_sym_COLON, - [60098] = 2, + ACTIONS(3119), 1, + anon_sym_GT, + [60335] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3112), 1, + ACTIONS(3121), 1, anon_sym_RPAREN, - [60105] = 2, + [60342] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3114), 1, + ACTIONS(3123), 1, anon_sym_GT, - [60112] = 2, + [60349] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3116), 1, + ACTIONS(3125), 1, anon_sym_LBRACE, - [60119] = 2, + [60356] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3118), 1, - anon_sym_COLON, - [60126] = 2, + ACTIONS(3127), 1, + anon_sym_LPAREN2, + [60363] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1392), 1, + ACTIONS(1534), 1, sym__statement_break, - [60133] = 2, + [60370] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3120), 1, - sym_identifier, - [60140] = 2, + ACTIONS(3129), 1, + anon_sym_RBRACE, + [60377] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3122), 1, + ACTIONS(3131), 1, anon_sym_LBRACE, - [60147] = 2, + [60384] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3124), 1, - anon_sym_GT, - [60154] = 2, + ACTIONS(3133), 1, + anon_sym_RPAREN, + [60391] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3126), 1, + ACTIONS(3135), 1, anon_sym_LBRACE, - [60161] = 2, + [60398] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3128), 1, + ACTIONS(3137), 1, anon_sym_RPAREN, - [60168] = 2, + [60405] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3130), 1, - anon_sym_COLON, - [60175] = 2, + ACTIONS(3139), 1, + anon_sym_EQ_GT, + [60412] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3132), 1, - anon_sym_COLON, - [60182] = 2, + ACTIONS(1536), 1, + sym__statement_break, + [60419] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3134), 1, - anon_sym_GT, - [60189] = 2, + ACTIONS(3141), 1, + anon_sym_COLON, + [60426] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3136), 1, + ACTIONS(3143), 1, anon_sym_LBRACE, - [60196] = 2, + [60433] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3138), 1, - anon_sym_RPAREN, - [60203] = 2, + ACTIONS(3145), 1, + anon_sym_COLON, + [60440] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3140), 1, + ACTIONS(3147), 1, anon_sym_RPAREN, - [60210] = 2, + [60447] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3142), 1, - sym_identifier, - [60217] = 2, + ACTIONS(3149), 1, + sym__statement_break, + [60454] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3144), 1, - anon_sym_COLON, - [60224] = 2, + ACTIONS(1538), 1, + sym__statement_break, + [60461] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1492), 1, + ACTIONS(1432), 1, sym__statement_break, - [60231] = 2, + [60468] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1905), 1, - anon_sym_COLON, - [60238] = 2, + ACTIONS(3151), 1, + sym__statement_break, + [60475] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3146), 1, + ACTIONS(3153), 1, anon_sym_COLON, - [60245] = 2, + [60482] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3148), 1, - anon_sym_COLON, - [60252] = 2, + ACTIONS(1542), 1, + sym__statement_break, + [60489] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3150), 1, + ACTIONS(3155), 1, anon_sym_LPAREN, - [60259] = 2, + [60496] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3152), 1, - anon_sym_LPAREN, - [60266] = 2, + ACTIONS(3157), 1, + anon_sym_COLON, + [60503] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3154), 1, + ACTIONS(3159), 1, anon_sym_PIPE, - [60273] = 2, + [60510] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1494), 1, - sym__statement_break, - [60280] = 2, + ACTIONS(3161), 1, + sym_identifier, + [60517] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1496), 1, + ACTIONS(1544), 1, sym__statement_break, - [60287] = 2, + [60524] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3156), 1, - sym__statement_break, - [60294] = 2, + ACTIONS(3163), 1, + sym_identifier, + [60531] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3158), 1, + ACTIONS(3165), 1, anon_sym_COLON, - [60301] = 2, + [60538] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1889), 1, + ACTIONS(1883), 1, anon_sym_COLON, - [60308] = 2, + [60545] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1424), 1, - sym__statement_break, - [60315] = 2, + ACTIONS(3167), 1, + ts_builtin_sym_end, + [60552] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3160), 1, - sym_identifier, - [60322] = 2, + ACTIONS(1568), 1, + sym__statement_break, + [60559] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3162), 1, + ACTIONS(3169), 1, anon_sym_LPAREN, - [60329] = 2, + [60566] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1500), 1, - sym__statement_break, - [60336] = 2, + ACTIONS(3171), 1, + anon_sym_LPAREN, + [60573] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3164), 1, + ACTIONS(3173), 1, anon_sym_LPAREN2, - [60343] = 2, + [60580] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3166), 1, - anon_sym_COLON, - [60350] = 2, + ACTIONS(3175), 1, + anon_sym_LPAREN, + [60587] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3168), 1, + ACTIONS(3177), 1, anon_sym_RPAREN, - [60357] = 2, + [60594] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3170), 1, - anon_sym_RBRACE, - [60364] = 2, + ACTIONS(3179), 1, + anon_sym_module, + [60601] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3172), 1, - anon_sym_DOT, - [60371] = 2, + ACTIONS(1546), 1, + sym__statement_break, + [60608] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1502), 1, - sym__statement_break, - [60378] = 2, + ACTIONS(3181), 1, + sym_identifier, + [60615] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(3183), 1, sym__statement_break, - [60385] = 2, + [60622] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3174), 1, + ACTIONS(3185), 1, sym__statement_break, - [60392] = 2, + [60629] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3176), 1, - sym_identifier, - [60399] = 2, + ACTIONS(3187), 1, + anon_sym_RBRACE, + [60636] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1504), 1, + ACTIONS(1548), 1, sym__statement_break, - [60406] = 2, + [60643] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3178), 1, - anon_sym_LBRACE, - [60413] = 2, + ACTIONS(3189), 1, + sym_identifier, + [60650] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3180), 1, + ACTIONS(3191), 1, anon_sym_LPAREN, - [60420] = 2, + [60657] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3182), 1, - anon_sym_LBRACE, - [60427] = 2, + ACTIONS(3193), 1, + anon_sym_EQ_GT, + [60664] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1740), 1, + ACTIONS(1744), 1, anon_sym_RPAREN, - [60434] = 2, + [60671] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3184), 1, - anon_sym_LPAREN, - [60441] = 2, + ACTIONS(3195), 1, + anon_sym_EQ, + [60678] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3186), 1, + ACTIONS(3197), 1, sym_identifier, - [60448] = 2, + [60685] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3188), 1, - anon_sym_else, - [60455] = 2, + ACTIONS(664), 1, + sym__statement_break, + [60692] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3190), 1, + ACTIONS(3199), 1, anon_sym_else, - [60462] = 2, + [60699] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3192), 1, + ACTIONS(3201), 1, anon_sym_LPAREN, - [60469] = 2, + [60706] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3194), 1, + ACTIONS(3203), 1, anon_sym_RPAREN, - [60476] = 2, + [60713] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1506), 1, + ACTIONS(1550), 1, sym__statement_break, - [60483] = 2, + [60720] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2339), 1, - anon_sym_RBRACE, - [60490] = 2, + ACTIONS(3205), 1, + sym_identifier, + [60727] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3196), 1, + ACTIONS(3207), 1, sym_identifier, - [60497] = 2, + [60734] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3198), 1, + ACTIONS(3209), 1, sym_identifier, - [60504] = 2, + [60741] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3200), 1, - sym__statement_break, - [60511] = 2, + ACTIONS(3211), 1, + anon_sym_LBRACE, + [60748] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1426), 1, - sym__statement_break, - [60518] = 2, + ACTIONS(3213), 1, + sym_identifier, + [60755] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3202), 1, + ACTIONS(3215), 1, anon_sym_LBRACE, - [60525] = 2, + [60762] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3204), 1, + ACTIONS(3217), 1, anon_sym_LPAREN, - [60532] = 2, + [60769] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3206), 1, - sym__statement_break, - [60539] = 2, + ACTIONS(3219), 1, + anon_sym_effect, + [60776] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3208), 1, + ACTIONS(3221), 1, sym_identifier, - [60546] = 2, + [60783] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3210), 1, - anon_sym_LBRACE, - [60553] = 2, + ACTIONS(3223), 1, + anon_sym_COLON, + [60790] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3212), 1, + ACTIONS(3225), 1, anon_sym_LPAREN, - [60560] = 2, + [60797] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3214), 1, + ACTIONS(3227), 1, sym_identifier, - [60567] = 2, + [60804] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3216), 1, + ACTIONS(3229), 1, sym_identifier, - [60574] = 2, + [60811] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1568), 1, - sym__statement_break, - [60581] = 2, + ACTIONS(3231), 1, + anon_sym_LBRACE, + [60818] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3218), 1, - anon_sym_RPAREN, - [60588] = 2, + ACTIONS(2611), 1, + anon_sym_EQ_GT, + [60825] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3220), 1, + ACTIONS(3233), 1, anon_sym_LBRACE, - [60595] = 2, + [60832] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3222), 1, + ACTIONS(3235), 1, sym_identifier, - [60602] = 2, + [60839] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3224), 1, - sym_identifier, - [60609] = 2, + ACTIONS(3237), 1, + anon_sym_DOT_DOT, + [60846] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3226), 1, + ACTIONS(3239), 1, sym_identifier, - [60616] = 2, + [60853] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1438), 1, + ACTIONS(3241), 1, sym__statement_break, - [60623] = 2, + [60860] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1440), 1, - sym__statement_break, - [60630] = 2, + ACTIONS(3243), 1, + anon_sym_COLON, + [60867] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3228), 1, + ACTIONS(3245), 1, sym_identifier, - [60637] = 2, + [60874] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3230), 1, + ACTIONS(3247), 1, anon_sym_LPAREN, - [60644] = 2, + [60881] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3232), 1, - sym__statement_break, - [60651] = 2, + ACTIONS(3249), 1, + anon_sym_COLON, + [60888] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3234), 1, + ACTIONS(3251), 1, sym_identifier, - [60658] = 2, + [60895] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3236), 1, + ACTIONS(3253), 1, sym_identifier, - [60665] = 2, + [60902] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3238), 1, - sym_identifier, - [60672] = 2, + ACTIONS(3255), 1, + anon_sym_RPAREN, + [60909] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3240), 1, + ACTIONS(3257), 1, anon_sym_GT, - [60679] = 2, + [60916] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3242), 1, - anon_sym_RBRACE, - [60686] = 2, + ACTIONS(1434), 1, + sym__statement_break, + [60923] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3244), 1, + ACTIONS(3259), 1, sym_identifier, - [60693] = 2, + [60930] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3246), 1, + ACTIONS(3261), 1, anon_sym_QMARK, - [60700] = 2, + [60937] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3248), 1, - anon_sym_EQ, - [60707] = 2, + ACTIONS(2340), 1, + anon_sym_RBRACE, + [60944] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3250), 1, + ACTIONS(3263), 1, anon_sym_LPAREN, - [60714] = 2, + [60951] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3252), 1, + ACTIONS(3265), 1, anon_sym_GT, - [60721] = 2, + [60958] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3254), 1, + ACTIONS(3267), 1, anon_sym_GT, - [60728] = 2, + [60965] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3256), 1, + ACTIONS(3269), 1, anon_sym_LPAREN, - [60735] = 2, + [60972] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3258), 1, + ACTIONS(3271), 1, anon_sym_GT, - [60742] = 2, + [60979] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1726), 1, - anon_sym_type, - [60749] = 2, + ACTIONS(3273), 1, + anon_sym_RBRACE, + [60986] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3260), 1, - anon_sym_RPAREN, - [60756] = 2, + ACTIONS(1554), 1, + sym__statement_break, + [60993] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3262), 1, + ACTIONS(3275), 1, anon_sym_LBRACE, - [60763] = 2, + [61000] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3264), 1, + ACTIONS(3277), 1, anon_sym_LPAREN, - [60770] = 2, + [61007] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3266), 1, - sym_identifier, - [60777] = 2, + ACTIONS(1412), 1, + sym__statement_break, + [61014] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3268), 1, + ACTIONS(3279), 1, anon_sym_LBRACE, - [60784] = 2, + [61021] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3270), 1, - anon_sym_EQ_GT, - [60791] = 2, + ACTIONS(3281), 1, + anon_sym_LPAREN2, + [61028] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3272), 1, + ACTIONS(3283), 1, sym_identifier, - [60798] = 2, + [61035] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3274), 1, + ACTIONS(3285), 1, anon_sym_LPAREN, - [60805] = 2, + [61042] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1772), 1, - anon_sym_LBRACE, - [60812] = 2, + ACTIONS(3287), 1, + sym__statement_break, + [61049] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3276), 1, + ACTIONS(3289), 1, sym_identifier, - [60819] = 2, + [61056] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3278), 1, + ACTIONS(3291), 1, anon_sym_QMARK, - [60826] = 2, + [61063] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3280), 1, + ACTIONS(3293), 1, anon_sym_fn, - [60833] = 2, + [61070] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3282), 1, + ACTIONS(3295), 1, anon_sym_effect, - [60840] = 2, + [61077] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3284), 1, + ACTIONS(3297), 1, anon_sym_module, - [60847] = 2, + [61084] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1510), 1, + ACTIONS(3299), 1, sym__statement_break, - [60854] = 2, + [61091] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1442), 1, - sym__statement_break, - [60861] = 2, + ACTIONS(3301), 1, + anon_sym_RPAREN, + [61098] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3286), 1, - sym_identifier, - [60868] = 2, + ACTIONS(3303), 1, + anon_sym_EQ_GT, + [61105] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3288), 1, + ACTIONS(3305), 1, anon_sym_fn, - [60875] = 2, + [61112] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3290), 1, + ACTIONS(3307), 1, anon_sym_effect, - [60882] = 2, + [61119] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3292), 1, + ACTIONS(3309), 1, anon_sym_module, - [60889] = 2, + [61126] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3294), 1, - sym_identifier, - [60896] = 2, + ACTIONS(1560), 1, + sym__statement_break, + [61133] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3296), 1, - anon_sym_LBRACE, - [60903] = 2, + ACTIONS(1564), 1, + sym__statement_break, + [61140] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3298), 1, + ACTIONS(3311), 1, anon_sym_DOT, - [60910] = 2, + [61147] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3300), 1, - anon_sym_DOT_DOT, - [60917] = 2, + ACTIONS(3313), 1, + anon_sym_RBRACE, + [61154] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3302), 1, + ACTIONS(3315), 1, anon_sym_GT, - [60924] = 2, + [61161] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1512), 1, + ACTIONS(1556), 1, sym__statement_break, - [60931] = 2, + [61168] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3304), 1, + ACTIONS(3317), 1, sym_identifier, - [60938] = 2, + [61175] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3306), 1, + ACTIONS(3319), 1, anon_sym_GT, - [60945] = 2, + [61182] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1572), 1, - sym__statement_break, - [60952] = 2, + ACTIONS(3321), 1, + sym_identifier, + [61189] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2716), 1, - anon_sym_EQ_GT, - [60959] = 2, + ACTIONS(554), 1, + sym__statement_break, + [61196] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1514), 1, - sym__statement_break, - [60966] = 2, + ACTIONS(1714), 1, + anon_sym_type, + [61203] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3308), 1, - sym_identifier, - [60973] = 2, + ACTIONS(3323), 1, + anon_sym_GT, + [61210] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1516), 1, - sym__statement_break, - [60980] = 2, + ACTIONS(3325), 1, + anon_sym_COLON, + [61217] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3310), 1, + ACTIONS(3327), 1, anon_sym_DOT, - [60987] = 2, + [61224] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3312), 1, + ACTIONS(3329), 1, anon_sym_RBRACE, - [60994] = 2, + [61231] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3314), 1, + ACTIONS(3331), 1, anon_sym_LPAREN, - [61001] = 2, + [61238] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1518), 1, - sym__statement_break, - [61008] = 2, + ACTIONS(1795), 1, + anon_sym_LBRACE, + [61245] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1428), 1, + ACTIONS(1566), 1, sym__statement_break, - [61015] = 2, + [61252] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3316), 1, - sym_identifier, - [61022] = 2, + ACTIONS(3333), 1, + anon_sym_EQ_GT, + [61259] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1430), 1, - sym__statement_break, - [61029] = 2, + ACTIONS(3335), 1, + anon_sym_LPAREN, + [61266] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3318), 1, - sym_identifier, - [61036] = 2, + ACTIONS(2519), 1, + anon_sym_RBRACE, + [61273] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3320), 1, + ACTIONS(3337), 1, anon_sym_LPAREN, - [61043] = 2, + [61280] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2433), 1, + ACTIONS(3339), 1, anon_sym_RBRACE, - [61050] = 2, + [61287] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1524), 1, - sym__statement_break, - [61057] = 2, + ACTIONS(3341), 1, + anon_sym_GT, + [61294] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3322), 1, - anon_sym_RBRACE, - [61064] = 2, + ACTIONS(3343), 1, + anon_sym_RBRACK, + [61301] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3324), 1, - anon_sym_GT, - [61071] = 2, + ACTIONS(3345), 1, + anon_sym_effect, + [61308] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3326), 1, - anon_sym_DASH_GT, - [61078] = 2, + ACTIONS(3347), 1, + anon_sym_RPAREN, + [61315] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1484), 1, + ACTIONS(3349), 1, sym__statement_break, }; @@ -55844,1528 +56104,1538 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(226)] = 23555, [SMALL_STATE(227)] = 23611, [SMALL_STATE(228)] = 23667, - [SMALL_STATE(229)] = 23715, - [SMALL_STATE(230)] = 23763, - [SMALL_STATE(231)] = 23820, - [SMALL_STATE(232)] = 23870, - [SMALL_STATE(233)] = 23920, - [SMALL_STATE(234)] = 23995, - [SMALL_STATE(235)] = 24068, - [SMALL_STATE(236)] = 24131, - [SMALL_STATE(237)] = 24188, - [SMALL_STATE(238)] = 24263, - [SMALL_STATE(239)] = 24338, - [SMALL_STATE(240)] = 24407, - [SMALL_STATE(241)] = 24474, - [SMALL_STATE(242)] = 24549, - [SMALL_STATE(243)] = 24624, - [SMALL_STATE(244)] = 24685, - [SMALL_STATE(245)] = 24740, - [SMALL_STATE(246)] = 24815, - [SMALL_STATE(247)] = 24890, - [SMALL_STATE(248)] = 24965, - [SMALL_STATE(249)] = 25040, - [SMALL_STATE(250)] = 25113, - [SMALL_STATE(251)] = 25164, - [SMALL_STATE(252)] = 25239, - [SMALL_STATE(253)] = 25314, - [SMALL_STATE(254)] = 25389, - [SMALL_STATE(255)] = 25444, - [SMALL_STATE(256)] = 25489, - [SMALL_STATE(257)] = 25564, - [SMALL_STATE(258)] = 25608, - [SMALL_STATE(259)] = 25652, - [SMALL_STATE(260)] = 25696, - [SMALL_STATE(261)] = 25740, - [SMALL_STATE(262)] = 25784, - [SMALL_STATE(263)] = 25828, - [SMALL_STATE(264)] = 25872, - [SMALL_STATE(265)] = 25916, - [SMALL_STATE(266)] = 25960, - [SMALL_STATE(267)] = 26004, - [SMALL_STATE(268)] = 26048, - [SMALL_STATE(269)] = 26092, - [SMALL_STATE(270)] = 26136, - [SMALL_STATE(271)] = 26180, - [SMALL_STATE(272)] = 26224, - [SMALL_STATE(273)] = 26268, - [SMALL_STATE(274)] = 26312, - [SMALL_STATE(275)] = 26356, - [SMALL_STATE(276)] = 26400, - [SMALL_STATE(277)] = 26444, - [SMALL_STATE(278)] = 26488, - [SMALL_STATE(279)] = 26532, - [SMALL_STATE(280)] = 26576, - [SMALL_STATE(281)] = 26620, - [SMALL_STATE(282)] = 26664, - [SMALL_STATE(283)] = 26708, - [SMALL_STATE(284)] = 26752, - [SMALL_STATE(285)] = 26796, - [SMALL_STATE(286)] = 26840, - [SMALL_STATE(287)] = 26884, - [SMALL_STATE(288)] = 26928, - [SMALL_STATE(289)] = 26972, - [SMALL_STATE(290)] = 27016, - [SMALL_STATE(291)] = 27060, - [SMALL_STATE(292)] = 27104, - [SMALL_STATE(293)] = 27158, - [SMALL_STATE(294)] = 27202, - [SMALL_STATE(295)] = 27246, - [SMALL_STATE(296)] = 27293, - [SMALL_STATE(297)] = 27340, - [SMALL_STATE(298)] = 27408, - [SMALL_STATE(299)] = 27478, - [SMALL_STATE(300)] = 27548, - [SMALL_STATE(301)] = 27618, - [SMALL_STATE(302)] = 27688, - [SMALL_STATE(303)] = 27758, - [SMALL_STATE(304)] = 27828, - [SMALL_STATE(305)] = 27898, - [SMALL_STATE(306)] = 27968, - [SMALL_STATE(307)] = 28038, - [SMALL_STATE(308)] = 28108, - [SMALL_STATE(309)] = 28178, - [SMALL_STATE(310)] = 28248, - [SMALL_STATE(311)] = 28318, - [SMALL_STATE(312)] = 28388, - [SMALL_STATE(313)] = 28458, - [SMALL_STATE(314)] = 28528, - [SMALL_STATE(315)] = 28598, - [SMALL_STATE(316)] = 28668, - [SMALL_STATE(317)] = 28738, - [SMALL_STATE(318)] = 28808, - [SMALL_STATE(319)] = 28878, - [SMALL_STATE(320)] = 28948, - [SMALL_STATE(321)] = 29018, - [SMALL_STATE(322)] = 29088, - [SMALL_STATE(323)] = 29158, - [SMALL_STATE(324)] = 29228, - [SMALL_STATE(325)] = 29298, - [SMALL_STATE(326)] = 29368, - [SMALL_STATE(327)] = 29438, - [SMALL_STATE(328)] = 29508, - [SMALL_STATE(329)] = 29578, - [SMALL_STATE(330)] = 29626, - [SMALL_STATE(331)] = 29696, - [SMALL_STATE(332)] = 29748, - [SMALL_STATE(333)] = 29818, - [SMALL_STATE(334)] = 29888, - [SMALL_STATE(335)] = 29942, - [SMALL_STATE(336)] = 30002, - [SMALL_STATE(337)] = 30066, - [SMALL_STATE(338)] = 30128, - [SMALL_STATE(339)] = 30186, - [SMALL_STATE(340)] = 30238, - [SMALL_STATE(341)] = 30308, - [SMALL_STATE(342)] = 30378, - [SMALL_STATE(343)] = 30446, - [SMALL_STATE(344)] = 30516, - [SMALL_STATE(345)] = 30586, - [SMALL_STATE(346)] = 30656, - [SMALL_STATE(347)] = 30726, - [SMALL_STATE(348)] = 30796, - [SMALL_STATE(349)] = 30866, - [SMALL_STATE(350)] = 30936, - [SMALL_STATE(351)] = 31006, - [SMALL_STATE(352)] = 31076, - [SMALL_STATE(353)] = 31146, - [SMALL_STATE(354)] = 31216, - [SMALL_STATE(355)] = 31258, - [SMALL_STATE(356)] = 31328, - [SMALL_STATE(357)] = 31398, - [SMALL_STATE(358)] = 31439, - [SMALL_STATE(359)] = 31480, - [SMALL_STATE(360)] = 31521, - [SMALL_STATE(361)] = 31562, - [SMALL_STATE(362)] = 31603, - [SMALL_STATE(363)] = 31644, - [SMALL_STATE(364)] = 31685, - [SMALL_STATE(365)] = 31726, - [SMALL_STATE(366)] = 31767, - [SMALL_STATE(367)] = 31808, - [SMALL_STATE(368)] = 31849, - [SMALL_STATE(369)] = 31890, - [SMALL_STATE(370)] = 31931, - [SMALL_STATE(371)] = 31972, - [SMALL_STATE(372)] = 32013, - [SMALL_STATE(373)] = 32054, - [SMALL_STATE(374)] = 32095, - [SMALL_STATE(375)] = 32136, - [SMALL_STATE(376)] = 32177, - [SMALL_STATE(377)] = 32218, - [SMALL_STATE(378)] = 32259, - [SMALL_STATE(379)] = 32300, - [SMALL_STATE(380)] = 32341, - [SMALL_STATE(381)] = 32382, - [SMALL_STATE(382)] = 32423, - [SMALL_STATE(383)] = 32464, - [SMALL_STATE(384)] = 32505, - [SMALL_STATE(385)] = 32546, - [SMALL_STATE(386)] = 32587, - [SMALL_STATE(387)] = 32628, - [SMALL_STATE(388)] = 32669, - [SMALL_STATE(389)] = 32710, - [SMALL_STATE(390)] = 32751, - [SMALL_STATE(391)] = 32792, - [SMALL_STATE(392)] = 32833, - [SMALL_STATE(393)] = 32874, - [SMALL_STATE(394)] = 32915, - [SMALL_STATE(395)] = 32985, - [SMALL_STATE(396)] = 33055, - [SMALL_STATE(397)] = 33096, - [SMALL_STATE(398)] = 33136, - [SMALL_STATE(399)] = 33172, - [SMALL_STATE(400)] = 33221, - [SMALL_STATE(401)] = 33283, - [SMALL_STATE(402)] = 33345, - [SMALL_STATE(403)] = 33407, - [SMALL_STATE(404)] = 33451, - [SMALL_STATE(405)] = 33513, - [SMALL_STATE(406)] = 33575, - [SMALL_STATE(407)] = 33637, - [SMALL_STATE(408)] = 33699, - [SMALL_STATE(409)] = 33761, - [SMALL_STATE(410)] = 33807, - [SMALL_STATE(411)] = 33853, - [SMALL_STATE(412)] = 33915, - [SMALL_STATE(413)] = 33977, - [SMALL_STATE(414)] = 34039, - [SMALL_STATE(415)] = 34089, - [SMALL_STATE(416)] = 34151, - [SMALL_STATE(417)] = 34213, - [SMALL_STATE(418)] = 34275, - [SMALL_STATE(419)] = 34337, - [SMALL_STATE(420)] = 34399, - [SMALL_STATE(421)] = 34461, - [SMALL_STATE(422)] = 34523, - [SMALL_STATE(423)] = 34585, - [SMALL_STATE(424)] = 34647, - [SMALL_STATE(425)] = 34709, - [SMALL_STATE(426)] = 34771, - [SMALL_STATE(427)] = 34833, - [SMALL_STATE(428)] = 34895, - [SMALL_STATE(429)] = 34957, - [SMALL_STATE(430)] = 35019, - [SMALL_STATE(431)] = 35081, - [SMALL_STATE(432)] = 35143, - [SMALL_STATE(433)] = 35205, - [SMALL_STATE(434)] = 35267, - [SMALL_STATE(435)] = 35329, - [SMALL_STATE(436)] = 35391, - [SMALL_STATE(437)] = 35453, - [SMALL_STATE(438)] = 35490, - [SMALL_STATE(439)] = 35527, - [SMALL_STATE(440)] = 35568, - [SMALL_STATE(441)] = 35632, - [SMALL_STATE(442)] = 35692, - [SMALL_STATE(443)] = 35724, - [SMALL_STATE(444)] = 35784, - [SMALL_STATE(445)] = 35848, - [SMALL_STATE(446)] = 35908, - [SMALL_STATE(447)] = 35968, - [SMALL_STATE(448)] = 36028, - [SMALL_STATE(449)] = 36088, - [SMALL_STATE(450)] = 36148, - [SMALL_STATE(451)] = 36208, - [SMALL_STATE(452)] = 36268, - [SMALL_STATE(453)] = 36332, - [SMALL_STATE(454)] = 36374, - [SMALL_STATE(455)] = 36432, - [SMALL_STATE(456)] = 36490, - [SMALL_STATE(457)] = 36550, - [SMALL_STATE(458)] = 36614, - [SMALL_STATE(459)] = 36674, - [SMALL_STATE(460)] = 36734, - [SMALL_STATE(461)] = 36772, - [SMALL_STATE(462)] = 36832, - [SMALL_STATE(463)] = 36892, - [SMALL_STATE(464)] = 36956, - [SMALL_STATE(465)] = 37020, - [SMALL_STATE(466)] = 37064, - [SMALL_STATE(467)] = 37114, - [SMALL_STATE(468)] = 37178, - [SMALL_STATE(469)] = 37232, - [SMALL_STATE(470)] = 37284, - [SMALL_STATE(471)] = 37332, - [SMALL_STATE(472)] = 37374, - [SMALL_STATE(473)] = 37433, - [SMALL_STATE(474)] = 37464, - [SMALL_STATE(475)] = 37495, - [SMALL_STATE(476)] = 37526, - [SMALL_STATE(477)] = 37557, - [SMALL_STATE(478)] = 37588, - [SMALL_STATE(479)] = 37619, - [SMALL_STATE(480)] = 37650, - [SMALL_STATE(481)] = 37681, - [SMALL_STATE(482)] = 37712, - [SMALL_STATE(483)] = 37743, - [SMALL_STATE(484)] = 37774, - [SMALL_STATE(485)] = 37805, - [SMALL_STATE(486)] = 37836, - [SMALL_STATE(487)] = 37867, - [SMALL_STATE(488)] = 37898, - [SMALL_STATE(489)] = 37929, - [SMALL_STATE(490)] = 37990, - [SMALL_STATE(491)] = 38045, - [SMALL_STATE(492)] = 38076, - [SMALL_STATE(493)] = 38107, - [SMALL_STATE(494)] = 38138, - [SMALL_STATE(495)] = 38169, - [SMALL_STATE(496)] = 38200, - [SMALL_STATE(497)] = 38259, - [SMALL_STATE(498)] = 38290, - [SMALL_STATE(499)] = 38349, - [SMALL_STATE(500)] = 38380, - [SMALL_STATE(501)] = 38411, - [SMALL_STATE(502)] = 38442, - [SMALL_STATE(503)] = 38501, - [SMALL_STATE(504)] = 38536, - [SMALL_STATE(505)] = 38597, - [SMALL_STATE(506)] = 38652, - [SMALL_STATE(507)] = 38711, - [SMALL_STATE(508)] = 38772, - [SMALL_STATE(509)] = 38803, - [SMALL_STATE(510)] = 38834, - [SMALL_STATE(511)] = 38865, - [SMALL_STATE(512)] = 38926, - [SMALL_STATE(513)] = 38985, - [SMALL_STATE(514)] = 39016, - [SMALL_STATE(515)] = 39047, - [SMALL_STATE(516)] = 39078, - [SMALL_STATE(517)] = 39109, - [SMALL_STATE(518)] = 39140, - [SMALL_STATE(519)] = 39199, - [SMALL_STATE(520)] = 39260, - [SMALL_STATE(521)] = 39315, - [SMALL_STATE(522)] = 39376, - [SMALL_STATE(523)] = 39437, - [SMALL_STATE(524)] = 39468, - [SMALL_STATE(525)] = 39499, - [SMALL_STATE(526)] = 39530, - [SMALL_STATE(527)] = 39561, - [SMALL_STATE(528)] = 39619, - [SMALL_STATE(529)] = 39677, - [SMALL_STATE(530)] = 39735, - [SMALL_STATE(531)] = 39793, - [SMALL_STATE(532)] = 39851, - [SMALL_STATE(533)] = 39909, - [SMALL_STATE(534)] = 39967, - [SMALL_STATE(535)] = 40025, - [SMALL_STATE(536)] = 40083, - [SMALL_STATE(537)] = 40141, - [SMALL_STATE(538)] = 40199, - [SMALL_STATE(539)] = 40251, - [SMALL_STATE(540)] = 40309, - [SMALL_STATE(541)] = 40361, - [SMALL_STATE(542)] = 40419, - [SMALL_STATE(543)] = 40477, - [SMALL_STATE(544)] = 40529, - [SMALL_STATE(545)] = 40587, - [SMALL_STATE(546)] = 40645, - [SMALL_STATE(547)] = 40703, - [SMALL_STATE(548)] = 40757, - [SMALL_STATE(549)] = 40815, - [SMALL_STATE(550)] = 40873, - [SMALL_STATE(551)] = 40931, - [SMALL_STATE(552)] = 40983, - [SMALL_STATE(553)] = 41041, - [SMALL_STATE(554)] = 41099, - [SMALL_STATE(555)] = 41157, - [SMALL_STATE(556)] = 41215, - [SMALL_STATE(557)] = 41273, - [SMALL_STATE(558)] = 41331, - [SMALL_STATE(559)] = 41389, - [SMALL_STATE(560)] = 41447, - [SMALL_STATE(561)] = 41505, - [SMALL_STATE(562)] = 41563, - [SMALL_STATE(563)] = 41621, - [SMALL_STATE(564)] = 41679, - [SMALL_STATE(565)] = 41737, - [SMALL_STATE(566)] = 41795, - [SMALL_STATE(567)] = 41853, - [SMALL_STATE(568)] = 41911, - [SMALL_STATE(569)] = 41969, - [SMALL_STATE(570)] = 42027, - [SMALL_STATE(571)] = 42085, - [SMALL_STATE(572)] = 42143, - [SMALL_STATE(573)] = 42195, - [SMALL_STATE(574)] = 42253, - [SMALL_STATE(575)] = 42311, - [SMALL_STATE(576)] = 42369, - [SMALL_STATE(577)] = 42427, - [SMALL_STATE(578)] = 42485, - [SMALL_STATE(579)] = 42543, - [SMALL_STATE(580)] = 42601, - [SMALL_STATE(581)] = 42653, - [SMALL_STATE(582)] = 42711, - [SMALL_STATE(583)] = 42763, - [SMALL_STATE(584)] = 42821, - [SMALL_STATE(585)] = 42879, - [SMALL_STATE(586)] = 42937, - [SMALL_STATE(587)] = 42995, - [SMALL_STATE(588)] = 43053, - [SMALL_STATE(589)] = 43111, - [SMALL_STATE(590)] = 43169, - [SMALL_STATE(591)] = 43201, - [SMALL_STATE(592)] = 43259, - [SMALL_STATE(593)] = 43317, - [SMALL_STATE(594)] = 43375, - [SMALL_STATE(595)] = 43427, - [SMALL_STATE(596)] = 43485, - [SMALL_STATE(597)] = 43543, - [SMALL_STATE(598)] = 43601, - [SMALL_STATE(599)] = 43659, - [SMALL_STATE(600)] = 43717, - [SMALL_STATE(601)] = 43775, - [SMALL_STATE(602)] = 43833, - [SMALL_STATE(603)] = 43891, - [SMALL_STATE(604)] = 43949, - [SMALL_STATE(605)] = 44003, - [SMALL_STATE(606)] = 44061, - [SMALL_STATE(607)] = 44119, - [SMALL_STATE(608)] = 44177, - [SMALL_STATE(609)] = 44235, - [SMALL_STATE(610)] = 44293, - [SMALL_STATE(611)] = 44351, - [SMALL_STATE(612)] = 44380, - [SMALL_STATE(613)] = 44435, - [SMALL_STATE(614)] = 44484, - [SMALL_STATE(615)] = 44539, - [SMALL_STATE(616)] = 44594, - [SMALL_STATE(617)] = 44643, - [SMALL_STATE(618)] = 44672, - [SMALL_STATE(619)] = 44727, - [SMALL_STATE(620)] = 44776, - [SMALL_STATE(621)] = 44831, - [SMALL_STATE(622)] = 44870, - [SMALL_STATE(623)] = 44899, - [SMALL_STATE(624)] = 44928, - [SMALL_STATE(625)] = 44983, - [SMALL_STATE(626)] = 45012, - [SMALL_STATE(627)] = 45067, - [SMALL_STATE(628)] = 45115, - [SMALL_STATE(629)] = 45163, - [SMALL_STATE(630)] = 45211, - [SMALL_STATE(631)] = 45256, - [SMALL_STATE(632)] = 45301, - [SMALL_STATE(633)] = 45346, - [SMALL_STATE(634)] = 45379, - [SMALL_STATE(635)] = 45412, - [SMALL_STATE(636)] = 45460, - [SMALL_STATE(637)] = 45508, - [SMALL_STATE(638)] = 45556, - [SMALL_STATE(639)] = 45604, - [SMALL_STATE(640)] = 45652, - [SMALL_STATE(641)] = 45700, - [SMALL_STATE(642)] = 45748, - [SMALL_STATE(643)] = 45796, - [SMALL_STATE(644)] = 45844, - [SMALL_STATE(645)] = 45871, - [SMALL_STATE(646)] = 45897, - [SMALL_STATE(647)] = 45923, - [SMALL_STATE(648)] = 45949, - [SMALL_STATE(649)] = 45970, - [SMALL_STATE(650)] = 45991, - [SMALL_STATE(651)] = 46016, - [SMALL_STATE(652)] = 46041, - [SMALL_STATE(653)] = 46066, - [SMALL_STATE(654)] = 46093, - [SMALL_STATE(655)] = 46120, - [SMALL_STATE(656)] = 46141, - [SMALL_STATE(657)] = 46166, - [SMALL_STATE(658)] = 46197, - [SMALL_STATE(659)] = 46217, - [SMALL_STATE(660)] = 46251, - [SMALL_STATE(661)] = 46271, - [SMALL_STATE(662)] = 46291, - [SMALL_STATE(663)] = 46325, - [SMALL_STATE(664)] = 46347, - [SMALL_STATE(665)] = 46367, - [SMALL_STATE(666)] = 46387, - [SMALL_STATE(667)] = 46407, - [SMALL_STATE(668)] = 46429, - [SMALL_STATE(669)] = 46449, - [SMALL_STATE(670)] = 46483, - [SMALL_STATE(671)] = 46503, - [SMALL_STATE(672)] = 46525, - [SMALL_STATE(673)] = 46545, - [SMALL_STATE(674)] = 46565, - [SMALL_STATE(675)] = 46587, - [SMALL_STATE(676)] = 46621, - [SMALL_STATE(677)] = 46641, - [SMALL_STATE(678)] = 46661, - [SMALL_STATE(679)] = 46681, - [SMALL_STATE(680)] = 46701, - [SMALL_STATE(681)] = 46721, - [SMALL_STATE(682)] = 46755, - [SMALL_STATE(683)] = 46775, - [SMALL_STATE(684)] = 46795, - [SMALL_STATE(685)] = 46815, - [SMALL_STATE(686)] = 46837, - [SMALL_STATE(687)] = 46871, - [SMALL_STATE(688)] = 46905, - [SMALL_STATE(689)] = 46939, - [SMALL_STATE(690)] = 46958, - [SMALL_STATE(691)] = 46977, - [SMALL_STATE(692)] = 47002, - [SMALL_STATE(693)] = 47021, - [SMALL_STATE(694)] = 47040, - [SMALL_STATE(695)] = 47059, - [SMALL_STATE(696)] = 47078, - [SMALL_STATE(697)] = 47097, - [SMALL_STATE(698)] = 47116, - [SMALL_STATE(699)] = 47135, - [SMALL_STATE(700)] = 47154, - [SMALL_STATE(701)] = 47173, - [SMALL_STATE(702)] = 47192, - [SMALL_STATE(703)] = 47211, - [SMALL_STATE(704)] = 47230, - [SMALL_STATE(705)] = 47249, - [SMALL_STATE(706)] = 47268, - [SMALL_STATE(707)] = 47287, - [SMALL_STATE(708)] = 47306, - [SMALL_STATE(709)] = 47325, - [SMALL_STATE(710)] = 47344, - [SMALL_STATE(711)] = 47363, - [SMALL_STATE(712)] = 47382, - [SMALL_STATE(713)] = 47401, - [SMALL_STATE(714)] = 47420, - [SMALL_STATE(715)] = 47439, - [SMALL_STATE(716)] = 47458, - [SMALL_STATE(717)] = 47477, - [SMALL_STATE(718)] = 47496, - [SMALL_STATE(719)] = 47515, - [SMALL_STATE(720)] = 47534, - [SMALL_STATE(721)] = 47553, - [SMALL_STATE(722)] = 47572, - [SMALL_STATE(723)] = 47591, - [SMALL_STATE(724)] = 47610, - [SMALL_STATE(725)] = 47629, - [SMALL_STATE(726)] = 47648, - [SMALL_STATE(727)] = 47667, - [SMALL_STATE(728)] = 47686, - [SMALL_STATE(729)] = 47705, - [SMALL_STATE(730)] = 47724, - [SMALL_STATE(731)] = 47743, - [SMALL_STATE(732)] = 47762, - [SMALL_STATE(733)] = 47781, - [SMALL_STATE(734)] = 47800, - [SMALL_STATE(735)] = 47819, - [SMALL_STATE(736)] = 47838, - [SMALL_STATE(737)] = 47857, - [SMALL_STATE(738)] = 47876, - [SMALL_STATE(739)] = 47895, - [SMALL_STATE(740)] = 47914, - [SMALL_STATE(741)] = 47933, - [SMALL_STATE(742)] = 47952, - [SMALL_STATE(743)] = 47971, - [SMALL_STATE(744)] = 47990, - [SMALL_STATE(745)] = 48009, - [SMALL_STATE(746)] = 48028, - [SMALL_STATE(747)] = 48047, - [SMALL_STATE(748)] = 48066, - [SMALL_STATE(749)] = 48085, - [SMALL_STATE(750)] = 48104, - [SMALL_STATE(751)] = 48123, - [SMALL_STATE(752)] = 48142, - [SMALL_STATE(753)] = 48169, - [SMALL_STATE(754)] = 48188, - [SMALL_STATE(755)] = 48207, - [SMALL_STATE(756)] = 48226, - [SMALL_STATE(757)] = 48245, - [SMALL_STATE(758)] = 48264, - [SMALL_STATE(759)] = 48283, - [SMALL_STATE(760)] = 48302, - [SMALL_STATE(761)] = 48336, - [SMALL_STATE(762)] = 48360, - [SMALL_STATE(763)] = 48394, - [SMALL_STATE(764)] = 48428, - [SMALL_STATE(765)] = 48462, - [SMALL_STATE(766)] = 48486, - [SMALL_STATE(767)] = 48520, - [SMALL_STATE(768)] = 48542, - [SMALL_STATE(769)] = 48576, - [SMALL_STATE(770)] = 48610, - [SMALL_STATE(771)] = 48644, - [SMALL_STATE(772)] = 48678, - [SMALL_STATE(773)] = 48712, - [SMALL_STATE(774)] = 48734, - [SMALL_STATE(775)] = 48756, - [SMALL_STATE(776)] = 48790, - [SMALL_STATE(777)] = 48824, - [SMALL_STATE(778)] = 48858, - [SMALL_STATE(779)] = 48892, - [SMALL_STATE(780)] = 48914, - [SMALL_STATE(781)] = 48948, - [SMALL_STATE(782)] = 48982, - [SMALL_STATE(783)] = 49016, - [SMALL_STATE(784)] = 49050, - [SMALL_STATE(785)] = 49084, - [SMALL_STATE(786)] = 49118, - [SMALL_STATE(787)] = 49152, - [SMALL_STATE(788)] = 49186, - [SMALL_STATE(789)] = 49220, - [SMALL_STATE(790)] = 49244, - [SMALL_STATE(791)] = 49278, - [SMALL_STATE(792)] = 49312, - [SMALL_STATE(793)] = 49346, - [SMALL_STATE(794)] = 49380, - [SMALL_STATE(795)] = 49414, - [SMALL_STATE(796)] = 49448, - [SMALL_STATE(797)] = 49482, - [SMALL_STATE(798)] = 49516, - [SMALL_STATE(799)] = 49550, - [SMALL_STATE(800)] = 49574, - [SMALL_STATE(801)] = 49608, - [SMALL_STATE(802)] = 49632, - [SMALL_STATE(803)] = 49653, - [SMALL_STATE(804)] = 49672, - [SMALL_STATE(805)] = 49691, - [SMALL_STATE(806)] = 49712, - [SMALL_STATE(807)] = 49733, - [SMALL_STATE(808)] = 49752, - [SMALL_STATE(809)] = 49771, - [SMALL_STATE(810)] = 49790, - [SMALL_STATE(811)] = 49807, - [SMALL_STATE(812)] = 49826, - [SMALL_STATE(813)] = 49847, - [SMALL_STATE(814)] = 49868, - [SMALL_STATE(815)] = 49897, - [SMALL_STATE(816)] = 49926, - [SMALL_STATE(817)] = 49955, - [SMALL_STATE(818)] = 49984, - [SMALL_STATE(819)] = 50005, - [SMALL_STATE(820)] = 50034, - [SMALL_STATE(821)] = 50069, - [SMALL_STATE(822)] = 50098, - [SMALL_STATE(823)] = 50119, - [SMALL_STATE(824)] = 50145, - [SMALL_STATE(825)] = 50171, - [SMALL_STATE(826)] = 50191, - [SMALL_STATE(827)] = 50217, - [SMALL_STATE(828)] = 50251, - [SMALL_STATE(829)] = 50283, - [SMALL_STATE(830)] = 50311, - [SMALL_STATE(831)] = 50337, - [SMALL_STATE(832)] = 50363, - [SMALL_STATE(833)] = 50389, - [SMALL_STATE(834)] = 50407, - [SMALL_STATE(835)] = 50433, - [SMALL_STATE(836)] = 50451, - [SMALL_STATE(837)] = 50477, - [SMALL_STATE(838)] = 50503, - [SMALL_STATE(839)] = 50521, - [SMALL_STATE(840)] = 50544, - [SMALL_STATE(841)] = 50567, - [SMALL_STATE(842)] = 50590, - [SMALL_STATE(843)] = 50605, - [SMALL_STATE(844)] = 50620, - [SMALL_STATE(845)] = 50643, - [SMALL_STATE(846)] = 50670, - [SMALL_STATE(847)] = 50693, - [SMALL_STATE(848)] = 50716, - [SMALL_STATE(849)] = 50739, - [SMALL_STATE(850)] = 50762, - [SMALL_STATE(851)] = 50785, - [SMALL_STATE(852)] = 50808, - [SMALL_STATE(853)] = 50831, - [SMALL_STATE(854)] = 50854, - [SMALL_STATE(855)] = 50877, - [SMALL_STATE(856)] = 50900, - [SMALL_STATE(857)] = 50923, - [SMALL_STATE(858)] = 50946, - [SMALL_STATE(859)] = 50961, - [SMALL_STATE(860)] = 50976, - [SMALL_STATE(861)] = 50999, - [SMALL_STATE(862)] = 51022, - [SMALL_STATE(863)] = 51045, - [SMALL_STATE(864)] = 51068, - [SMALL_STATE(865)] = 51091, - [SMALL_STATE(866)] = 51114, - [SMALL_STATE(867)] = 51133, - [SMALL_STATE(868)] = 51152, - [SMALL_STATE(869)] = 51175, - [SMALL_STATE(870)] = 51198, - [SMALL_STATE(871)] = 51221, - [SMALL_STATE(872)] = 51244, - [SMALL_STATE(873)] = 51267, - [SMALL_STATE(874)] = 51290, - [SMALL_STATE(875)] = 51313, - [SMALL_STATE(876)] = 51336, - [SMALL_STATE(877)] = 51359, - [SMALL_STATE(878)] = 51382, - [SMALL_STATE(879)] = 51405, - [SMALL_STATE(880)] = 51420, - [SMALL_STATE(881)] = 51435, - [SMALL_STATE(882)] = 51450, - [SMALL_STATE(883)] = 51465, - [SMALL_STATE(884)] = 51488, - [SMALL_STATE(885)] = 51511, - [SMALL_STATE(886)] = 51534, - [SMALL_STATE(887)] = 51557, - [SMALL_STATE(888)] = 51580, - [SMALL_STATE(889)] = 51603, - [SMALL_STATE(890)] = 51626, - [SMALL_STATE(891)] = 51649, - [SMALL_STATE(892)] = 51664, - [SMALL_STATE(893)] = 51687, - [SMALL_STATE(894)] = 51710, - [SMALL_STATE(895)] = 51725, - [SMALL_STATE(896)] = 51740, - [SMALL_STATE(897)] = 51763, - [SMALL_STATE(898)] = 51786, - [SMALL_STATE(899)] = 51801, - [SMALL_STATE(900)] = 51824, - [SMALL_STATE(901)] = 51847, - [SMALL_STATE(902)] = 51870, - [SMALL_STATE(903)] = 51893, - [SMALL_STATE(904)] = 51908, - [SMALL_STATE(905)] = 51931, - [SMALL_STATE(906)] = 51954, - [SMALL_STATE(907)] = 51977, - [SMALL_STATE(908)] = 52000, - [SMALL_STATE(909)] = 52015, - [SMALL_STATE(910)] = 52038, - [SMALL_STATE(911)] = 52061, - [SMALL_STATE(912)] = 52084, - [SMALL_STATE(913)] = 52107, - [SMALL_STATE(914)] = 52130, - [SMALL_STATE(915)] = 52153, - [SMALL_STATE(916)] = 52176, - [SMALL_STATE(917)] = 52199, - [SMALL_STATE(918)] = 52222, - [SMALL_STATE(919)] = 52245, - [SMALL_STATE(920)] = 52268, - [SMALL_STATE(921)] = 52291, - [SMALL_STATE(922)] = 52314, - [SMALL_STATE(923)] = 52329, - [SMALL_STATE(924)] = 52344, - [SMALL_STATE(925)] = 52367, - [SMALL_STATE(926)] = 52390, - [SMALL_STATE(927)] = 52413, - [SMALL_STATE(928)] = 52436, - [SMALL_STATE(929)] = 52459, - [SMALL_STATE(930)] = 52482, - [SMALL_STATE(931)] = 52497, - [SMALL_STATE(932)] = 52520, - [SMALL_STATE(933)] = 52535, - [SMALL_STATE(934)] = 52558, - [SMALL_STATE(935)] = 52573, - [SMALL_STATE(936)] = 52588, - [SMALL_STATE(937)] = 52611, - [SMALL_STATE(938)] = 52633, - [SMALL_STATE(939)] = 52647, - [SMALL_STATE(940)] = 52662, - [SMALL_STATE(941)] = 52677, - [SMALL_STATE(942)] = 52692, - [SMALL_STATE(943)] = 52707, - [SMALL_STATE(944)] = 52722, - [SMALL_STATE(945)] = 52737, - [SMALL_STATE(946)] = 52752, - [SMALL_STATE(947)] = 52767, - [SMALL_STATE(948)] = 52790, - [SMALL_STATE(949)] = 52805, - [SMALL_STATE(950)] = 52826, - [SMALL_STATE(951)] = 52841, - [SMALL_STATE(952)] = 52864, - [SMALL_STATE(953)] = 52885, - [SMALL_STATE(954)] = 52900, - [SMALL_STATE(955)] = 52921, - [SMALL_STATE(956)] = 52942, - [SMALL_STATE(957)] = 52963, - [SMALL_STATE(958)] = 52978, - [SMALL_STATE(959)] = 52999, - [SMALL_STATE(960)] = 53022, - [SMALL_STATE(961)] = 53043, - [SMALL_STATE(962)] = 53066, - [SMALL_STATE(963)] = 53087, - [SMALL_STATE(964)] = 53102, - [SMALL_STATE(965)] = 53117, - [SMALL_STATE(966)] = 53140, - [SMALL_STATE(967)] = 53155, - [SMALL_STATE(968)] = 53178, - [SMALL_STATE(969)] = 53193, - [SMALL_STATE(970)] = 53209, - [SMALL_STATE(971)] = 53231, - [SMALL_STATE(972)] = 53245, - [SMALL_STATE(973)] = 53263, - [SMALL_STATE(974)] = 53285, - [SMALL_STATE(975)] = 53307, - [SMALL_STATE(976)] = 53329, - [SMALL_STATE(977)] = 53351, - [SMALL_STATE(978)] = 53373, - [SMALL_STATE(979)] = 53395, - [SMALL_STATE(980)] = 53417, - [SMALL_STATE(981)] = 53437, - [SMALL_STATE(982)] = 53459, - [SMALL_STATE(983)] = 53481, - [SMALL_STATE(984)] = 53503, - [SMALL_STATE(985)] = 53525, - [SMALL_STATE(986)] = 53547, - [SMALL_STATE(987)] = 53559, - [SMALL_STATE(988)] = 53581, - [SMALL_STATE(989)] = 53603, - [SMALL_STATE(990)] = 53625, - [SMALL_STATE(991)] = 53642, - [SMALL_STATE(992)] = 53659, - [SMALL_STATE(993)] = 53676, - [SMALL_STATE(994)] = 53693, - [SMALL_STATE(995)] = 53712, - [SMALL_STATE(996)] = 53729, - [SMALL_STATE(997)] = 53746, - [SMALL_STATE(998)] = 53765, - [SMALL_STATE(999)] = 53784, - [SMALL_STATE(1000)] = 53801, - [SMALL_STATE(1001)] = 53818, - [SMALL_STATE(1002)] = 53835, - [SMALL_STATE(1003)] = 53852, - [SMALL_STATE(1004)] = 53869, - [SMALL_STATE(1005)] = 53888, - [SMALL_STATE(1006)] = 53903, - [SMALL_STATE(1007)] = 53920, - [SMALL_STATE(1008)] = 53937, - [SMALL_STATE(1009)] = 53954, - [SMALL_STATE(1010)] = 53973, - [SMALL_STATE(1011)] = 53992, - [SMALL_STATE(1012)] = 54009, - [SMALL_STATE(1013)] = 54028, - [SMALL_STATE(1014)] = 54045, - [SMALL_STATE(1015)] = 54062, - [SMALL_STATE(1016)] = 54079, - [SMALL_STATE(1017)] = 54098, - [SMALL_STATE(1018)] = 54117, - [SMALL_STATE(1019)] = 54134, - [SMALL_STATE(1020)] = 54151, - [SMALL_STATE(1021)] = 54170, - [SMALL_STATE(1022)] = 54187, - [SMALL_STATE(1023)] = 54206, - [SMALL_STATE(1024)] = 54223, - [SMALL_STATE(1025)] = 54240, - [SMALL_STATE(1026)] = 54257, - [SMALL_STATE(1027)] = 54274, - [SMALL_STATE(1028)] = 54293, - [SMALL_STATE(1029)] = 54312, - [SMALL_STATE(1030)] = 54331, - [SMALL_STATE(1031)] = 54350, - [SMALL_STATE(1032)] = 54365, - [SMALL_STATE(1033)] = 54384, - [SMALL_STATE(1034)] = 54401, - [SMALL_STATE(1035)] = 54418, - [SMALL_STATE(1036)] = 54435, - [SMALL_STATE(1037)] = 54452, - [SMALL_STATE(1038)] = 54469, - [SMALL_STATE(1039)] = 54488, - [SMALL_STATE(1040)] = 54505, - [SMALL_STATE(1041)] = 54524, - [SMALL_STATE(1042)] = 54541, - [SMALL_STATE(1043)] = 54558, - [SMALL_STATE(1044)] = 54575, - [SMALL_STATE(1045)] = 54592, - [SMALL_STATE(1046)] = 54609, - [SMALL_STATE(1047)] = 54626, - [SMALL_STATE(1048)] = 54645, - [SMALL_STATE(1049)] = 54662, - [SMALL_STATE(1050)] = 54679, - [SMALL_STATE(1051)] = 54696, - [SMALL_STATE(1052)] = 54713, - [SMALL_STATE(1053)] = 54732, - [SMALL_STATE(1054)] = 54751, - [SMALL_STATE(1055)] = 54770, - [SMALL_STATE(1056)] = 54784, - [SMALL_STATE(1057)] = 54798, - [SMALL_STATE(1058)] = 54812, - [SMALL_STATE(1059)] = 54826, - [SMALL_STATE(1060)] = 54842, - [SMALL_STATE(1061)] = 54856, - [SMALL_STATE(1062)] = 54872, - [SMALL_STATE(1063)] = 54886, - [SMALL_STATE(1064)] = 54900, - [SMALL_STATE(1065)] = 54914, - [SMALL_STATE(1066)] = 54928, - [SMALL_STATE(1067)] = 54944, - [SMALL_STATE(1068)] = 54960, - [SMALL_STATE(1069)] = 54974, - [SMALL_STATE(1070)] = 54984, - [SMALL_STATE(1071)] = 54998, - [SMALL_STATE(1072)] = 55012, - [SMALL_STATE(1073)] = 55028, - [SMALL_STATE(1074)] = 55044, - [SMALL_STATE(1075)] = 55060, - [SMALL_STATE(1076)] = 55074, - [SMALL_STATE(1077)] = 55088, - [SMALL_STATE(1078)] = 55102, - [SMALL_STATE(1079)] = 55114, - [SMALL_STATE(1080)] = 55130, - [SMALL_STATE(1081)] = 55144, - [SMALL_STATE(1082)] = 55154, - [SMALL_STATE(1083)] = 55164, - [SMALL_STATE(1084)] = 55178, - [SMALL_STATE(1085)] = 55192, - [SMALL_STATE(1086)] = 55202, - [SMALL_STATE(1087)] = 55212, - [SMALL_STATE(1088)] = 55226, - [SMALL_STATE(1089)] = 55240, - [SMALL_STATE(1090)] = 55250, - [SMALL_STATE(1091)] = 55266, - [SMALL_STATE(1092)] = 55276, - [SMALL_STATE(1093)] = 55290, - [SMALL_STATE(1094)] = 55300, - [SMALL_STATE(1095)] = 55314, - [SMALL_STATE(1096)] = 55324, - [SMALL_STATE(1097)] = 55334, - [SMALL_STATE(1098)] = 55350, - [SMALL_STATE(1099)] = 55364, - [SMALL_STATE(1100)] = 55374, - [SMALL_STATE(1101)] = 55388, - [SMALL_STATE(1102)] = 55402, - [SMALL_STATE(1103)] = 55416, - [SMALL_STATE(1104)] = 55426, - [SMALL_STATE(1105)] = 55440, - [SMALL_STATE(1106)] = 55454, - [SMALL_STATE(1107)] = 55468, - [SMALL_STATE(1108)] = 55484, - [SMALL_STATE(1109)] = 55494, - [SMALL_STATE(1110)] = 55508, - [SMALL_STATE(1111)] = 55524, - [SMALL_STATE(1112)] = 55540, - [SMALL_STATE(1113)] = 55550, - [SMALL_STATE(1114)] = 55566, - [SMALL_STATE(1115)] = 55580, - [SMALL_STATE(1116)] = 55590, - [SMALL_STATE(1117)] = 55600, - [SMALL_STATE(1118)] = 55614, - [SMALL_STATE(1119)] = 55627, - [SMALL_STATE(1120)] = 55640, - [SMALL_STATE(1121)] = 55653, - [SMALL_STATE(1122)] = 55666, - [SMALL_STATE(1123)] = 55675, - [SMALL_STATE(1124)] = 55686, - [SMALL_STATE(1125)] = 55699, - [SMALL_STATE(1126)] = 55712, - [SMALL_STATE(1127)] = 55725, - [SMALL_STATE(1128)] = 55738, - [SMALL_STATE(1129)] = 55751, - [SMALL_STATE(1130)] = 55760, - [SMALL_STATE(1131)] = 55773, - [SMALL_STATE(1132)] = 55786, - [SMALL_STATE(1133)] = 55799, - [SMALL_STATE(1134)] = 55812, - [SMALL_STATE(1135)] = 55825, - [SMALL_STATE(1136)] = 55838, - [SMALL_STATE(1137)] = 55851, - [SMALL_STATE(1138)] = 55864, - [SMALL_STATE(1139)] = 55877, - [SMALL_STATE(1140)] = 55890, - [SMALL_STATE(1141)] = 55903, - [SMALL_STATE(1142)] = 55916, - [SMALL_STATE(1143)] = 55929, - [SMALL_STATE(1144)] = 55942, - [SMALL_STATE(1145)] = 55955, - [SMALL_STATE(1146)] = 55968, - [SMALL_STATE(1147)] = 55981, - [SMALL_STATE(1148)] = 55994, - [SMALL_STATE(1149)] = 56007, - [SMALL_STATE(1150)] = 56020, - [SMALL_STATE(1151)] = 56033, - [SMALL_STATE(1152)] = 56046, - [SMALL_STATE(1153)] = 56059, - [SMALL_STATE(1154)] = 56072, - [SMALL_STATE(1155)] = 56083, - [SMALL_STATE(1156)] = 56096, - [SMALL_STATE(1157)] = 56109, - [SMALL_STATE(1158)] = 56122, - [SMALL_STATE(1159)] = 56135, - [SMALL_STATE(1160)] = 56148, - [SMALL_STATE(1161)] = 56161, - [SMALL_STATE(1162)] = 56174, - [SMALL_STATE(1163)] = 56187, - [SMALL_STATE(1164)] = 56200, - [SMALL_STATE(1165)] = 56213, - [SMALL_STATE(1166)] = 56226, - [SMALL_STATE(1167)] = 56239, - [SMALL_STATE(1168)] = 56252, - [SMALL_STATE(1169)] = 56265, - [SMALL_STATE(1170)] = 56278, - [SMALL_STATE(1171)] = 56291, - [SMALL_STATE(1172)] = 56304, - [SMALL_STATE(1173)] = 56317, - [SMALL_STATE(1174)] = 56330, - [SMALL_STATE(1175)] = 56343, - [SMALL_STATE(1176)] = 56356, - [SMALL_STATE(1177)] = 56369, - [SMALL_STATE(1178)] = 56382, - [SMALL_STATE(1179)] = 56395, - [SMALL_STATE(1180)] = 56408, - [SMALL_STATE(1181)] = 56421, - [SMALL_STATE(1182)] = 56434, - [SMALL_STATE(1183)] = 56447, - [SMALL_STATE(1184)] = 56460, - [SMALL_STATE(1185)] = 56473, - [SMALL_STATE(1186)] = 56486, - [SMALL_STATE(1187)] = 56499, - [SMALL_STATE(1188)] = 56510, - [SMALL_STATE(1189)] = 56523, - [SMALL_STATE(1190)] = 56536, - [SMALL_STATE(1191)] = 56549, - [SMALL_STATE(1192)] = 56562, - [SMALL_STATE(1193)] = 56573, - [SMALL_STATE(1194)] = 56586, - [SMALL_STATE(1195)] = 56597, - [SMALL_STATE(1196)] = 56610, - [SMALL_STATE(1197)] = 56623, - [SMALL_STATE(1198)] = 56636, - [SMALL_STATE(1199)] = 56649, - [SMALL_STATE(1200)] = 56662, - [SMALL_STATE(1201)] = 56675, - [SMALL_STATE(1202)] = 56688, - [SMALL_STATE(1203)] = 56699, - [SMALL_STATE(1204)] = 56712, - [SMALL_STATE(1205)] = 56725, - [SMALL_STATE(1206)] = 56738, - [SMALL_STATE(1207)] = 56751, - [SMALL_STATE(1208)] = 56764, - [SMALL_STATE(1209)] = 56777, - [SMALL_STATE(1210)] = 56788, - [SMALL_STATE(1211)] = 56801, - [SMALL_STATE(1212)] = 56814, - [SMALL_STATE(1213)] = 56827, - [SMALL_STATE(1214)] = 56840, - [SMALL_STATE(1215)] = 56853, - [SMALL_STATE(1216)] = 56864, - [SMALL_STATE(1217)] = 56877, - [SMALL_STATE(1218)] = 56890, - [SMALL_STATE(1219)] = 56899, - [SMALL_STATE(1220)] = 56912, - [SMALL_STATE(1221)] = 56921, - [SMALL_STATE(1222)] = 56934, - [SMALL_STATE(1223)] = 56947, - [SMALL_STATE(1224)] = 56960, - [SMALL_STATE(1225)] = 56973, - [SMALL_STATE(1226)] = 56984, - [SMALL_STATE(1227)] = 56997, - [SMALL_STATE(1228)] = 57008, - [SMALL_STATE(1229)] = 57021, - [SMALL_STATE(1230)] = 57034, - [SMALL_STATE(1231)] = 57043, - [SMALL_STATE(1232)] = 57056, - [SMALL_STATE(1233)] = 57069, - [SMALL_STATE(1234)] = 57082, - [SMALL_STATE(1235)] = 57095, - [SMALL_STATE(1236)] = 57108, - [SMALL_STATE(1237)] = 57119, - [SMALL_STATE(1238)] = 57128, - [SMALL_STATE(1239)] = 57141, - [SMALL_STATE(1240)] = 57152, - [SMALL_STATE(1241)] = 57165, - [SMALL_STATE(1242)] = 57178, - [SMALL_STATE(1243)] = 57187, - [SMALL_STATE(1244)] = 57198, - [SMALL_STATE(1245)] = 57211, - [SMALL_STATE(1246)] = 57224, - [SMALL_STATE(1247)] = 57237, - [SMALL_STATE(1248)] = 57250, - [SMALL_STATE(1249)] = 57263, - [SMALL_STATE(1250)] = 57276, - [SMALL_STATE(1251)] = 57285, - [SMALL_STATE(1252)] = 57298, - [SMALL_STATE(1253)] = 57311, - [SMALL_STATE(1254)] = 57324, - [SMALL_STATE(1255)] = 57337, - [SMALL_STATE(1256)] = 57350, - [SMALL_STATE(1257)] = 57363, - [SMALL_STATE(1258)] = 57376, - [SMALL_STATE(1259)] = 57389, - [SMALL_STATE(1260)] = 57402, - [SMALL_STATE(1261)] = 57415, - [SMALL_STATE(1262)] = 57426, - [SMALL_STATE(1263)] = 57436, - [SMALL_STATE(1264)] = 57446, - [SMALL_STATE(1265)] = 57454, - [SMALL_STATE(1266)] = 57464, - [SMALL_STATE(1267)] = 57474, - [SMALL_STATE(1268)] = 57484, - [SMALL_STATE(1269)] = 57492, - [SMALL_STATE(1270)] = 57502, - [SMALL_STATE(1271)] = 57512, - [SMALL_STATE(1272)] = 57522, - [SMALL_STATE(1273)] = 57530, - [SMALL_STATE(1274)] = 57540, - [SMALL_STATE(1275)] = 57548, - [SMALL_STATE(1276)] = 57558, - [SMALL_STATE(1277)] = 57566, - [SMALL_STATE(1278)] = 57574, - [SMALL_STATE(1279)] = 57582, - [SMALL_STATE(1280)] = 57590, - [SMALL_STATE(1281)] = 57598, - [SMALL_STATE(1282)] = 57606, - [SMALL_STATE(1283)] = 57616, - [SMALL_STATE(1284)] = 57626, - [SMALL_STATE(1285)] = 57634, - [SMALL_STATE(1286)] = 57644, - [SMALL_STATE(1287)] = 57654, - [SMALL_STATE(1288)] = 57664, - [SMALL_STATE(1289)] = 57672, - [SMALL_STATE(1290)] = 57680, - [SMALL_STATE(1291)] = 57690, - [SMALL_STATE(1292)] = 57700, - [SMALL_STATE(1293)] = 57708, - [SMALL_STATE(1294)] = 57718, - [SMALL_STATE(1295)] = 57726, - [SMALL_STATE(1296)] = 57734, - [SMALL_STATE(1297)] = 57742, - [SMALL_STATE(1298)] = 57752, - [SMALL_STATE(1299)] = 57762, - [SMALL_STATE(1300)] = 57772, - [SMALL_STATE(1301)] = 57782, - [SMALL_STATE(1302)] = 57792, - [SMALL_STATE(1303)] = 57802, - [SMALL_STATE(1304)] = 57812, - [SMALL_STATE(1305)] = 57822, - [SMALL_STATE(1306)] = 57832, - [SMALL_STATE(1307)] = 57842, - [SMALL_STATE(1308)] = 57852, - [SMALL_STATE(1309)] = 57862, - [SMALL_STATE(1310)] = 57870, - [SMALL_STATE(1311)] = 57878, - [SMALL_STATE(1312)] = 57888, - [SMALL_STATE(1313)] = 57896, - [SMALL_STATE(1314)] = 57906, - [SMALL_STATE(1315)] = 57916, - [SMALL_STATE(1316)] = 57924, - [SMALL_STATE(1317)] = 57934, - [SMALL_STATE(1318)] = 57944, - [SMALL_STATE(1319)] = 57952, - [SMALL_STATE(1320)] = 57962, - [SMALL_STATE(1321)] = 57972, - [SMALL_STATE(1322)] = 57982, - [SMALL_STATE(1323)] = 57992, - [SMALL_STATE(1324)] = 58002, - [SMALL_STATE(1325)] = 58012, - [SMALL_STATE(1326)] = 58022, - [SMALL_STATE(1327)] = 58032, - [SMALL_STATE(1328)] = 58042, - [SMALL_STATE(1329)] = 58052, - [SMALL_STATE(1330)] = 58060, - [SMALL_STATE(1331)] = 58070, - [SMALL_STATE(1332)] = 58078, - [SMALL_STATE(1333)] = 58088, - [SMALL_STATE(1334)] = 58098, - [SMALL_STATE(1335)] = 58108, - [SMALL_STATE(1336)] = 58118, - [SMALL_STATE(1337)] = 58128, - [SMALL_STATE(1338)] = 58138, - [SMALL_STATE(1339)] = 58148, - [SMALL_STATE(1340)] = 58158, - [SMALL_STATE(1341)] = 58168, - [SMALL_STATE(1342)] = 58178, - [SMALL_STATE(1343)] = 58188, - [SMALL_STATE(1344)] = 58196, - [SMALL_STATE(1345)] = 58204, - [SMALL_STATE(1346)] = 58214, - [SMALL_STATE(1347)] = 58222, - [SMALL_STATE(1348)] = 58232, - [SMALL_STATE(1349)] = 58242, - [SMALL_STATE(1350)] = 58252, - [SMALL_STATE(1351)] = 58262, - [SMALL_STATE(1352)] = 58272, - [SMALL_STATE(1353)] = 58282, - [SMALL_STATE(1354)] = 58290, - [SMALL_STATE(1355)] = 58300, - [SMALL_STATE(1356)] = 58310, - [SMALL_STATE(1357)] = 58320, - [SMALL_STATE(1358)] = 58330, - [SMALL_STATE(1359)] = 58340, - [SMALL_STATE(1360)] = 58348, - [SMALL_STATE(1361)] = 58355, - [SMALL_STATE(1362)] = 58362, - [SMALL_STATE(1363)] = 58369, - [SMALL_STATE(1364)] = 58376, - [SMALL_STATE(1365)] = 58383, - [SMALL_STATE(1366)] = 58390, - [SMALL_STATE(1367)] = 58397, - [SMALL_STATE(1368)] = 58404, - [SMALL_STATE(1369)] = 58411, - [SMALL_STATE(1370)] = 58418, - [SMALL_STATE(1371)] = 58425, - [SMALL_STATE(1372)] = 58432, - [SMALL_STATE(1373)] = 58439, - [SMALL_STATE(1374)] = 58446, - [SMALL_STATE(1375)] = 58453, - [SMALL_STATE(1376)] = 58460, - [SMALL_STATE(1377)] = 58467, - [SMALL_STATE(1378)] = 58474, - [SMALL_STATE(1379)] = 58481, - [SMALL_STATE(1380)] = 58488, - [SMALL_STATE(1381)] = 58495, - [SMALL_STATE(1382)] = 58502, - [SMALL_STATE(1383)] = 58509, - [SMALL_STATE(1384)] = 58516, - [SMALL_STATE(1385)] = 58523, - [SMALL_STATE(1386)] = 58530, - [SMALL_STATE(1387)] = 58537, - [SMALL_STATE(1388)] = 58544, - [SMALL_STATE(1389)] = 58551, - [SMALL_STATE(1390)] = 58558, - [SMALL_STATE(1391)] = 58565, - [SMALL_STATE(1392)] = 58572, - [SMALL_STATE(1393)] = 58579, - [SMALL_STATE(1394)] = 58586, - [SMALL_STATE(1395)] = 58593, - [SMALL_STATE(1396)] = 58600, - [SMALL_STATE(1397)] = 58607, - [SMALL_STATE(1398)] = 58614, - [SMALL_STATE(1399)] = 58621, - [SMALL_STATE(1400)] = 58628, - [SMALL_STATE(1401)] = 58635, - [SMALL_STATE(1402)] = 58642, - [SMALL_STATE(1403)] = 58649, - [SMALL_STATE(1404)] = 58656, - [SMALL_STATE(1405)] = 58663, - [SMALL_STATE(1406)] = 58670, - [SMALL_STATE(1407)] = 58677, - [SMALL_STATE(1408)] = 58684, - [SMALL_STATE(1409)] = 58691, - [SMALL_STATE(1410)] = 58698, - [SMALL_STATE(1411)] = 58705, - [SMALL_STATE(1412)] = 58712, - [SMALL_STATE(1413)] = 58719, - [SMALL_STATE(1414)] = 58726, - [SMALL_STATE(1415)] = 58733, - [SMALL_STATE(1416)] = 58740, - [SMALL_STATE(1417)] = 58747, - [SMALL_STATE(1418)] = 58754, - [SMALL_STATE(1419)] = 58761, - [SMALL_STATE(1420)] = 58768, - [SMALL_STATE(1421)] = 58775, - [SMALL_STATE(1422)] = 58782, - [SMALL_STATE(1423)] = 58789, - [SMALL_STATE(1424)] = 58796, - [SMALL_STATE(1425)] = 58803, - [SMALL_STATE(1426)] = 58810, - [SMALL_STATE(1427)] = 58817, - [SMALL_STATE(1428)] = 58824, - [SMALL_STATE(1429)] = 58831, - [SMALL_STATE(1430)] = 58838, - [SMALL_STATE(1431)] = 58845, - [SMALL_STATE(1432)] = 58852, - [SMALL_STATE(1433)] = 58859, - [SMALL_STATE(1434)] = 58866, - [SMALL_STATE(1435)] = 58873, - [SMALL_STATE(1436)] = 58880, - [SMALL_STATE(1437)] = 58887, - [SMALL_STATE(1438)] = 58894, - [SMALL_STATE(1439)] = 58901, - [SMALL_STATE(1440)] = 58908, - [SMALL_STATE(1441)] = 58915, - [SMALL_STATE(1442)] = 58922, - [SMALL_STATE(1443)] = 58929, - [SMALL_STATE(1444)] = 58936, - [SMALL_STATE(1445)] = 58943, - [SMALL_STATE(1446)] = 58950, - [SMALL_STATE(1447)] = 58957, - [SMALL_STATE(1448)] = 58964, - [SMALL_STATE(1449)] = 58971, - [SMALL_STATE(1450)] = 58978, - [SMALL_STATE(1451)] = 58985, - [SMALL_STATE(1452)] = 58992, - [SMALL_STATE(1453)] = 58999, - [SMALL_STATE(1454)] = 59006, - [SMALL_STATE(1455)] = 59013, - [SMALL_STATE(1456)] = 59020, - [SMALL_STATE(1457)] = 59027, - [SMALL_STATE(1458)] = 59034, - [SMALL_STATE(1459)] = 59041, - [SMALL_STATE(1460)] = 59048, - [SMALL_STATE(1461)] = 59055, - [SMALL_STATE(1462)] = 59062, - [SMALL_STATE(1463)] = 59069, - [SMALL_STATE(1464)] = 59076, - [SMALL_STATE(1465)] = 59083, - [SMALL_STATE(1466)] = 59090, - [SMALL_STATE(1467)] = 59097, - [SMALL_STATE(1468)] = 59104, - [SMALL_STATE(1469)] = 59111, - [SMALL_STATE(1470)] = 59118, - [SMALL_STATE(1471)] = 59125, - [SMALL_STATE(1472)] = 59132, - [SMALL_STATE(1473)] = 59139, - [SMALL_STATE(1474)] = 59146, - [SMALL_STATE(1475)] = 59153, - [SMALL_STATE(1476)] = 59160, - [SMALL_STATE(1477)] = 59167, - [SMALL_STATE(1478)] = 59174, - [SMALL_STATE(1479)] = 59181, - [SMALL_STATE(1480)] = 59188, - [SMALL_STATE(1481)] = 59195, - [SMALL_STATE(1482)] = 59202, - [SMALL_STATE(1483)] = 59209, - [SMALL_STATE(1484)] = 59216, - [SMALL_STATE(1485)] = 59223, - [SMALL_STATE(1486)] = 59230, - [SMALL_STATE(1487)] = 59237, - [SMALL_STATE(1488)] = 59244, - [SMALL_STATE(1489)] = 59251, - [SMALL_STATE(1490)] = 59258, - [SMALL_STATE(1491)] = 59265, - [SMALL_STATE(1492)] = 59272, - [SMALL_STATE(1493)] = 59279, - [SMALL_STATE(1494)] = 59286, - [SMALL_STATE(1495)] = 59293, - [SMALL_STATE(1496)] = 59300, - [SMALL_STATE(1497)] = 59307, - [SMALL_STATE(1498)] = 59314, - [SMALL_STATE(1499)] = 59321, - [SMALL_STATE(1500)] = 59328, - [SMALL_STATE(1501)] = 59335, - [SMALL_STATE(1502)] = 59342, - [SMALL_STATE(1503)] = 59349, - [SMALL_STATE(1504)] = 59356, - [SMALL_STATE(1505)] = 59363, - [SMALL_STATE(1506)] = 59370, - [SMALL_STATE(1507)] = 59377, - [SMALL_STATE(1508)] = 59384, - [SMALL_STATE(1509)] = 59391, - [SMALL_STATE(1510)] = 59398, - [SMALL_STATE(1511)] = 59405, - [SMALL_STATE(1512)] = 59412, - [SMALL_STATE(1513)] = 59419, - [SMALL_STATE(1514)] = 59426, - [SMALL_STATE(1515)] = 59433, - [SMALL_STATE(1516)] = 59440, - [SMALL_STATE(1517)] = 59447, - [SMALL_STATE(1518)] = 59454, - [SMALL_STATE(1519)] = 59461, - [SMALL_STATE(1520)] = 59468, - [SMALL_STATE(1521)] = 59475, - [SMALL_STATE(1522)] = 59482, - [SMALL_STATE(1523)] = 59489, - [SMALL_STATE(1524)] = 59496, - [SMALL_STATE(1525)] = 59503, - [SMALL_STATE(1526)] = 59510, - [SMALL_STATE(1527)] = 59517, - [SMALL_STATE(1528)] = 59524, - [SMALL_STATE(1529)] = 59531, - [SMALL_STATE(1530)] = 59538, - [SMALL_STATE(1531)] = 59545, - [SMALL_STATE(1532)] = 59552, - [SMALL_STATE(1533)] = 59559, - [SMALL_STATE(1534)] = 59566, - [SMALL_STATE(1535)] = 59573, - [SMALL_STATE(1536)] = 59580, - [SMALL_STATE(1537)] = 59587, - [SMALL_STATE(1538)] = 59594, - [SMALL_STATE(1539)] = 59601, - [SMALL_STATE(1540)] = 59608, - [SMALL_STATE(1541)] = 59615, - [SMALL_STATE(1542)] = 59622, - [SMALL_STATE(1543)] = 59629, - [SMALL_STATE(1544)] = 59636, - [SMALL_STATE(1545)] = 59643, - [SMALL_STATE(1546)] = 59650, - [SMALL_STATE(1547)] = 59657, - [SMALL_STATE(1548)] = 59664, - [SMALL_STATE(1549)] = 59671, - [SMALL_STATE(1550)] = 59678, - [SMALL_STATE(1551)] = 59685, - [SMALL_STATE(1552)] = 59692, - [SMALL_STATE(1553)] = 59699, - [SMALL_STATE(1554)] = 59706, - [SMALL_STATE(1555)] = 59713, - [SMALL_STATE(1556)] = 59720, - [SMALL_STATE(1557)] = 59727, - [SMALL_STATE(1558)] = 59734, - [SMALL_STATE(1559)] = 59741, - [SMALL_STATE(1560)] = 59748, - [SMALL_STATE(1561)] = 59755, - [SMALL_STATE(1562)] = 59762, - [SMALL_STATE(1563)] = 59769, - [SMALL_STATE(1564)] = 59776, - [SMALL_STATE(1565)] = 59783, - [SMALL_STATE(1566)] = 59790, - [SMALL_STATE(1567)] = 59797, - [SMALL_STATE(1568)] = 59804, - [SMALL_STATE(1569)] = 59811, - [SMALL_STATE(1570)] = 59818, - [SMALL_STATE(1571)] = 59825, - [SMALL_STATE(1572)] = 59832, - [SMALL_STATE(1573)] = 59839, - [SMALL_STATE(1574)] = 59846, - [SMALL_STATE(1575)] = 59853, - [SMALL_STATE(1576)] = 59860, - [SMALL_STATE(1577)] = 59867, - [SMALL_STATE(1578)] = 59874, - [SMALL_STATE(1579)] = 59881, - [SMALL_STATE(1580)] = 59888, - [SMALL_STATE(1581)] = 59895, - [SMALL_STATE(1582)] = 59902, - [SMALL_STATE(1583)] = 59909, - [SMALL_STATE(1584)] = 59916, - [SMALL_STATE(1585)] = 59923, - [SMALL_STATE(1586)] = 59930, - [SMALL_STATE(1587)] = 59937, - [SMALL_STATE(1588)] = 59944, - [SMALL_STATE(1589)] = 59951, - [SMALL_STATE(1590)] = 59958, - [SMALL_STATE(1591)] = 59965, - [SMALL_STATE(1592)] = 59972, - [SMALL_STATE(1593)] = 59979, - [SMALL_STATE(1594)] = 59986, - [SMALL_STATE(1595)] = 59993, - [SMALL_STATE(1596)] = 60000, - [SMALL_STATE(1597)] = 60007, - [SMALL_STATE(1598)] = 60014, - [SMALL_STATE(1599)] = 60021, - [SMALL_STATE(1600)] = 60028, - [SMALL_STATE(1601)] = 60035, - [SMALL_STATE(1602)] = 60042, - [SMALL_STATE(1603)] = 60049, - [SMALL_STATE(1604)] = 60056, - [SMALL_STATE(1605)] = 60063, - [SMALL_STATE(1606)] = 60070, - [SMALL_STATE(1607)] = 60077, - [SMALL_STATE(1608)] = 60084, - [SMALL_STATE(1609)] = 60091, - [SMALL_STATE(1610)] = 60098, - [SMALL_STATE(1611)] = 60105, - [SMALL_STATE(1612)] = 60112, - [SMALL_STATE(1613)] = 60119, - [SMALL_STATE(1614)] = 60126, - [SMALL_STATE(1615)] = 60133, - [SMALL_STATE(1616)] = 60140, - [SMALL_STATE(1617)] = 60147, - [SMALL_STATE(1618)] = 60154, - [SMALL_STATE(1619)] = 60161, - [SMALL_STATE(1620)] = 60168, - [SMALL_STATE(1621)] = 60175, - [SMALL_STATE(1622)] = 60182, - [SMALL_STATE(1623)] = 60189, - [SMALL_STATE(1624)] = 60196, - [SMALL_STATE(1625)] = 60203, - [SMALL_STATE(1626)] = 60210, - [SMALL_STATE(1627)] = 60217, - [SMALL_STATE(1628)] = 60224, - [SMALL_STATE(1629)] = 60231, - [SMALL_STATE(1630)] = 60238, - [SMALL_STATE(1631)] = 60245, - [SMALL_STATE(1632)] = 60252, - [SMALL_STATE(1633)] = 60259, - [SMALL_STATE(1634)] = 60266, - [SMALL_STATE(1635)] = 60273, - [SMALL_STATE(1636)] = 60280, - [SMALL_STATE(1637)] = 60287, - [SMALL_STATE(1638)] = 60294, - [SMALL_STATE(1639)] = 60301, - [SMALL_STATE(1640)] = 60308, - [SMALL_STATE(1641)] = 60315, - [SMALL_STATE(1642)] = 60322, - [SMALL_STATE(1643)] = 60329, - [SMALL_STATE(1644)] = 60336, - [SMALL_STATE(1645)] = 60343, - [SMALL_STATE(1646)] = 60350, - [SMALL_STATE(1647)] = 60357, - [SMALL_STATE(1648)] = 60364, - [SMALL_STATE(1649)] = 60371, - [SMALL_STATE(1650)] = 60378, - [SMALL_STATE(1651)] = 60385, - [SMALL_STATE(1652)] = 60392, - [SMALL_STATE(1653)] = 60399, - [SMALL_STATE(1654)] = 60406, - [SMALL_STATE(1655)] = 60413, - [SMALL_STATE(1656)] = 60420, - [SMALL_STATE(1657)] = 60427, - [SMALL_STATE(1658)] = 60434, - [SMALL_STATE(1659)] = 60441, - [SMALL_STATE(1660)] = 60448, - [SMALL_STATE(1661)] = 60455, - [SMALL_STATE(1662)] = 60462, - [SMALL_STATE(1663)] = 60469, - [SMALL_STATE(1664)] = 60476, - [SMALL_STATE(1665)] = 60483, - [SMALL_STATE(1666)] = 60490, - [SMALL_STATE(1667)] = 60497, - [SMALL_STATE(1668)] = 60504, - [SMALL_STATE(1669)] = 60511, - [SMALL_STATE(1670)] = 60518, - [SMALL_STATE(1671)] = 60525, - [SMALL_STATE(1672)] = 60532, - [SMALL_STATE(1673)] = 60539, - [SMALL_STATE(1674)] = 60546, - [SMALL_STATE(1675)] = 60553, - [SMALL_STATE(1676)] = 60560, - [SMALL_STATE(1677)] = 60567, - [SMALL_STATE(1678)] = 60574, - [SMALL_STATE(1679)] = 60581, - [SMALL_STATE(1680)] = 60588, - [SMALL_STATE(1681)] = 60595, - [SMALL_STATE(1682)] = 60602, - [SMALL_STATE(1683)] = 60609, - [SMALL_STATE(1684)] = 60616, - [SMALL_STATE(1685)] = 60623, - [SMALL_STATE(1686)] = 60630, - [SMALL_STATE(1687)] = 60637, - [SMALL_STATE(1688)] = 60644, - [SMALL_STATE(1689)] = 60651, - [SMALL_STATE(1690)] = 60658, - [SMALL_STATE(1691)] = 60665, - [SMALL_STATE(1692)] = 60672, - [SMALL_STATE(1693)] = 60679, - [SMALL_STATE(1694)] = 60686, - [SMALL_STATE(1695)] = 60693, - [SMALL_STATE(1696)] = 60700, - [SMALL_STATE(1697)] = 60707, - [SMALL_STATE(1698)] = 60714, - [SMALL_STATE(1699)] = 60721, - [SMALL_STATE(1700)] = 60728, - [SMALL_STATE(1701)] = 60735, - [SMALL_STATE(1702)] = 60742, - [SMALL_STATE(1703)] = 60749, - [SMALL_STATE(1704)] = 60756, - [SMALL_STATE(1705)] = 60763, - [SMALL_STATE(1706)] = 60770, - [SMALL_STATE(1707)] = 60777, - [SMALL_STATE(1708)] = 60784, - [SMALL_STATE(1709)] = 60791, - [SMALL_STATE(1710)] = 60798, - [SMALL_STATE(1711)] = 60805, - [SMALL_STATE(1712)] = 60812, - [SMALL_STATE(1713)] = 60819, - [SMALL_STATE(1714)] = 60826, - [SMALL_STATE(1715)] = 60833, - [SMALL_STATE(1716)] = 60840, - [SMALL_STATE(1717)] = 60847, - [SMALL_STATE(1718)] = 60854, - [SMALL_STATE(1719)] = 60861, - [SMALL_STATE(1720)] = 60868, - [SMALL_STATE(1721)] = 60875, - [SMALL_STATE(1722)] = 60882, - [SMALL_STATE(1723)] = 60889, - [SMALL_STATE(1724)] = 60896, - [SMALL_STATE(1725)] = 60903, - [SMALL_STATE(1726)] = 60910, - [SMALL_STATE(1727)] = 60917, - [SMALL_STATE(1728)] = 60924, - [SMALL_STATE(1729)] = 60931, - [SMALL_STATE(1730)] = 60938, - [SMALL_STATE(1731)] = 60945, - [SMALL_STATE(1732)] = 60952, - [SMALL_STATE(1733)] = 60959, - [SMALL_STATE(1734)] = 60966, - [SMALL_STATE(1735)] = 60973, - [SMALL_STATE(1736)] = 60980, - [SMALL_STATE(1737)] = 60987, - [SMALL_STATE(1738)] = 60994, - [SMALL_STATE(1739)] = 61001, - [SMALL_STATE(1740)] = 61008, - [SMALL_STATE(1741)] = 61015, - [SMALL_STATE(1742)] = 61022, - [SMALL_STATE(1743)] = 61029, - [SMALL_STATE(1744)] = 61036, - [SMALL_STATE(1745)] = 61043, - [SMALL_STATE(1746)] = 61050, - [SMALL_STATE(1747)] = 61057, - [SMALL_STATE(1748)] = 61064, - [SMALL_STATE(1749)] = 61071, - [SMALL_STATE(1750)] = 61078, + [SMALL_STATE(229)] = 23725, + [SMALL_STATE(230)] = 23773, + [SMALL_STATE(231)] = 23821, + [SMALL_STATE(232)] = 23872, + [SMALL_STATE(233)] = 23923, + [SMALL_STATE(234)] = 23999, + [SMALL_STATE(235)] = 24075, + [SMALL_STATE(236)] = 24127, + [SMALL_STATE(237)] = 24183, + [SMALL_STATE(238)] = 24259, + [SMALL_STATE(239)] = 24335, + [SMALL_STATE(240)] = 24381, + [SMALL_STATE(241)] = 24439, + [SMALL_STATE(242)] = 24503, + [SMALL_STATE(243)] = 24573, + [SMALL_STATE(244)] = 24641, + [SMALL_STATE(245)] = 24703, + [SMALL_STATE(246)] = 24759, + [SMALL_STATE(247)] = 24835, + [SMALL_STATE(248)] = 24911, + [SMALL_STATE(249)] = 24985, + [SMALL_STATE(250)] = 25061, + [SMALL_STATE(251)] = 25137, + [SMALL_STATE(252)] = 25211, + [SMALL_STATE(253)] = 25287, + [SMALL_STATE(254)] = 25363, + [SMALL_STATE(255)] = 25439, + [SMALL_STATE(256)] = 25515, + [SMALL_STATE(257)] = 25591, + [SMALL_STATE(258)] = 25636, + [SMALL_STATE(259)] = 25681, + [SMALL_STATE(260)] = 25726, + [SMALL_STATE(261)] = 25771, + [SMALL_STATE(262)] = 25816, + [SMALL_STATE(263)] = 25861, + [SMALL_STATE(264)] = 25906, + [SMALL_STATE(265)] = 25951, + [SMALL_STATE(266)] = 25996, + [SMALL_STATE(267)] = 26041, + [SMALL_STATE(268)] = 26086, + [SMALL_STATE(269)] = 26131, + [SMALL_STATE(270)] = 26176, + [SMALL_STATE(271)] = 26221, + [SMALL_STATE(272)] = 26266, + [SMALL_STATE(273)] = 26311, + [SMALL_STATE(274)] = 26356, + [SMALL_STATE(275)] = 26401, + [SMALL_STATE(276)] = 26446, + [SMALL_STATE(277)] = 26491, + [SMALL_STATE(278)] = 26536, + [SMALL_STATE(279)] = 26581, + [SMALL_STATE(280)] = 26626, + [SMALL_STATE(281)] = 26671, + [SMALL_STATE(282)] = 26716, + [SMALL_STATE(283)] = 26761, + [SMALL_STATE(284)] = 26806, + [SMALL_STATE(285)] = 26851, + [SMALL_STATE(286)] = 26896, + [SMALL_STATE(287)] = 26941, + [SMALL_STATE(288)] = 26986, + [SMALL_STATE(289)] = 27031, + [SMALL_STATE(290)] = 27076, + [SMALL_STATE(291)] = 27121, + [SMALL_STATE(292)] = 27166, + [SMALL_STATE(293)] = 27211, + [SMALL_STATE(294)] = 27256, + [SMALL_STATE(295)] = 27310, + [SMALL_STATE(296)] = 27357, + [SMALL_STATE(297)] = 27404, + [SMALL_STATE(298)] = 27474, + [SMALL_STATE(299)] = 27544, + [SMALL_STATE(300)] = 27614, + [SMALL_STATE(301)] = 27684, + [SMALL_STATE(302)] = 27754, + [SMALL_STATE(303)] = 27824, + [SMALL_STATE(304)] = 27894, + [SMALL_STATE(305)] = 27964, + [SMALL_STATE(306)] = 28034, + [SMALL_STATE(307)] = 28104, + [SMALL_STATE(308)] = 28174, + [SMALL_STATE(309)] = 28244, + [SMALL_STATE(310)] = 28314, + [SMALL_STATE(311)] = 28384, + [SMALL_STATE(312)] = 28454, + [SMALL_STATE(313)] = 28524, + [SMALL_STATE(314)] = 28594, + [SMALL_STATE(315)] = 28664, + [SMALL_STATE(316)] = 28734, + [SMALL_STATE(317)] = 28804, + [SMALL_STATE(318)] = 28874, + [SMALL_STATE(319)] = 28944, + [SMALL_STATE(320)] = 29014, + [SMALL_STATE(321)] = 29084, + [SMALL_STATE(322)] = 29154, + [SMALL_STATE(323)] = 29224, + [SMALL_STATE(324)] = 29294, + [SMALL_STATE(325)] = 29364, + [SMALL_STATE(326)] = 29434, + [SMALL_STATE(327)] = 29504, + [SMALL_STATE(328)] = 29574, + [SMALL_STATE(329)] = 29644, + [SMALL_STATE(330)] = 29714, + [SMALL_STATE(331)] = 29762, + [SMALL_STATE(332)] = 29832, + [SMALL_STATE(333)] = 29884, + [SMALL_STATE(334)] = 29954, + [SMALL_STATE(335)] = 30024, + [SMALL_STATE(336)] = 30078, + [SMALL_STATE(337)] = 30138, + [SMALL_STATE(338)] = 30208, + [SMALL_STATE(339)] = 30270, + [SMALL_STATE(340)] = 30328, + [SMALL_STATE(341)] = 30380, + [SMALL_STATE(342)] = 30450, + [SMALL_STATE(343)] = 30520, + [SMALL_STATE(344)] = 30588, + [SMALL_STATE(345)] = 30658, + [SMALL_STATE(346)] = 30728, + [SMALL_STATE(347)] = 30796, + [SMALL_STATE(348)] = 30866, + [SMALL_STATE(349)] = 30936, + [SMALL_STATE(350)] = 31006, + [SMALL_STATE(351)] = 31076, + [SMALL_STATE(352)] = 31146, + [SMALL_STATE(353)] = 31216, + [SMALL_STATE(354)] = 31286, + [SMALL_STATE(355)] = 31356, + [SMALL_STATE(356)] = 31398, + [SMALL_STATE(357)] = 31462, + [SMALL_STATE(358)] = 31503, + [SMALL_STATE(359)] = 31544, + [SMALL_STATE(360)] = 31585, + [SMALL_STATE(361)] = 31626, + [SMALL_STATE(362)] = 31667, + [SMALL_STATE(363)] = 31708, + [SMALL_STATE(364)] = 31749, + [SMALL_STATE(365)] = 31790, + [SMALL_STATE(366)] = 31831, + [SMALL_STATE(367)] = 31872, + [SMALL_STATE(368)] = 31913, + [SMALL_STATE(369)] = 31954, + [SMALL_STATE(370)] = 31995, + [SMALL_STATE(371)] = 32036, + [SMALL_STATE(372)] = 32077, + [SMALL_STATE(373)] = 32118, + [SMALL_STATE(374)] = 32159, + [SMALL_STATE(375)] = 32200, + [SMALL_STATE(376)] = 32241, + [SMALL_STATE(377)] = 32282, + [SMALL_STATE(378)] = 32323, + [SMALL_STATE(379)] = 32364, + [SMALL_STATE(380)] = 32405, + [SMALL_STATE(381)] = 32446, + [SMALL_STATE(382)] = 32487, + [SMALL_STATE(383)] = 32528, + [SMALL_STATE(384)] = 32569, + [SMALL_STATE(385)] = 32610, + [SMALL_STATE(386)] = 32651, + [SMALL_STATE(387)] = 32692, + [SMALL_STATE(388)] = 32733, + [SMALL_STATE(389)] = 32774, + [SMALL_STATE(390)] = 32815, + [SMALL_STATE(391)] = 32856, + [SMALL_STATE(392)] = 32897, + [SMALL_STATE(393)] = 32938, + [SMALL_STATE(394)] = 32979, + [SMALL_STATE(395)] = 33049, + [SMALL_STATE(396)] = 33119, + [SMALL_STATE(397)] = 33160, + [SMALL_STATE(398)] = 33200, + [SMALL_STATE(399)] = 33236, + [SMALL_STATE(400)] = 33285, + [SMALL_STATE(401)] = 33347, + [SMALL_STATE(402)] = 33409, + [SMALL_STATE(403)] = 33471, + [SMALL_STATE(404)] = 33533, + [SMALL_STATE(405)] = 33595, + [SMALL_STATE(406)] = 33641, + [SMALL_STATE(407)] = 33685, + [SMALL_STATE(408)] = 33735, + [SMALL_STATE(409)] = 33781, + [SMALL_STATE(410)] = 33843, + [SMALL_STATE(411)] = 33905, + [SMALL_STATE(412)] = 33967, + [SMALL_STATE(413)] = 34029, + [SMALL_STATE(414)] = 34091, + [SMALL_STATE(415)] = 34153, + [SMALL_STATE(416)] = 34215, + [SMALL_STATE(417)] = 34277, + [SMALL_STATE(418)] = 34339, + [SMALL_STATE(419)] = 34401, + [SMALL_STATE(420)] = 34463, + [SMALL_STATE(421)] = 34525, + [SMALL_STATE(422)] = 34587, + [SMALL_STATE(423)] = 34649, + [SMALL_STATE(424)] = 34711, + [SMALL_STATE(425)] = 34773, + [SMALL_STATE(426)] = 34835, + [SMALL_STATE(427)] = 34897, + [SMALL_STATE(428)] = 34959, + [SMALL_STATE(429)] = 35021, + [SMALL_STATE(430)] = 35083, + [SMALL_STATE(431)] = 35145, + [SMALL_STATE(432)] = 35207, + [SMALL_STATE(433)] = 35269, + [SMALL_STATE(434)] = 35331, + [SMALL_STATE(435)] = 35393, + [SMALL_STATE(436)] = 35455, + [SMALL_STATE(437)] = 35517, + [SMALL_STATE(438)] = 35558, + [SMALL_STATE(439)] = 35595, + [SMALL_STATE(440)] = 35632, + [SMALL_STATE(441)] = 35664, + [SMALL_STATE(442)] = 35728, + [SMALL_STATE(443)] = 35770, + [SMALL_STATE(444)] = 35830, + [SMALL_STATE(445)] = 35890, + [SMALL_STATE(446)] = 35954, + [SMALL_STATE(447)] = 36012, + [SMALL_STATE(448)] = 36072, + [SMALL_STATE(449)] = 36132, + [SMALL_STATE(450)] = 36192, + [SMALL_STATE(451)] = 36230, + [SMALL_STATE(452)] = 36290, + [SMALL_STATE(453)] = 36350, + [SMALL_STATE(454)] = 36410, + [SMALL_STATE(455)] = 36470, + [SMALL_STATE(456)] = 36530, + [SMALL_STATE(457)] = 36588, + [SMALL_STATE(458)] = 36652, + [SMALL_STATE(459)] = 36706, + [SMALL_STATE(460)] = 36758, + [SMALL_STATE(461)] = 36818, + [SMALL_STATE(462)] = 36878, + [SMALL_STATE(463)] = 36942, + [SMALL_STATE(464)] = 37006, + [SMALL_STATE(465)] = 37066, + [SMALL_STATE(466)] = 37114, + [SMALL_STATE(467)] = 37156, + [SMALL_STATE(468)] = 37220, + [SMALL_STATE(469)] = 37280, + [SMALL_STATE(470)] = 37344, + [SMALL_STATE(471)] = 37404, + [SMALL_STATE(472)] = 37448, + [SMALL_STATE(473)] = 37498, + [SMALL_STATE(474)] = 37558, + [SMALL_STATE(475)] = 37589, + [SMALL_STATE(476)] = 37620, + [SMALL_STATE(477)] = 37651, + [SMALL_STATE(478)] = 37710, + [SMALL_STATE(479)] = 37741, + [SMALL_STATE(480)] = 37772, + [SMALL_STATE(481)] = 37831, + [SMALL_STATE(482)] = 37892, + [SMALL_STATE(483)] = 37947, + [SMALL_STATE(484)] = 37978, + [SMALL_STATE(485)] = 38009, + [SMALL_STATE(486)] = 38040, + [SMALL_STATE(487)] = 38071, + [SMALL_STATE(488)] = 38132, + [SMALL_STATE(489)] = 38163, + [SMALL_STATE(490)] = 38194, + [SMALL_STATE(491)] = 38225, + [SMALL_STATE(492)] = 38256, + [SMALL_STATE(493)] = 38315, + [SMALL_STATE(494)] = 38346, + [SMALL_STATE(495)] = 38377, + [SMALL_STATE(496)] = 38438, + [SMALL_STATE(497)] = 38497, + [SMALL_STATE(498)] = 38528, + [SMALL_STATE(499)] = 38587, + [SMALL_STATE(500)] = 38618, + [SMALL_STATE(501)] = 38649, + [SMALL_STATE(502)] = 38680, + [SMALL_STATE(503)] = 38711, + [SMALL_STATE(504)] = 38742, + [SMALL_STATE(505)] = 38773, + [SMALL_STATE(506)] = 38804, + [SMALL_STATE(507)] = 38835, + [SMALL_STATE(508)] = 38896, + [SMALL_STATE(509)] = 38951, + [SMALL_STATE(510)] = 38982, + [SMALL_STATE(511)] = 39013, + [SMALL_STATE(512)] = 39044, + [SMALL_STATE(513)] = 39075, + [SMALL_STATE(514)] = 39136, + [SMALL_STATE(515)] = 39167, + [SMALL_STATE(516)] = 39228, + [SMALL_STATE(517)] = 39259, + [SMALL_STATE(518)] = 39290, + [SMALL_STATE(519)] = 39325, + [SMALL_STATE(520)] = 39380, + [SMALL_STATE(521)] = 39411, + [SMALL_STATE(522)] = 39442, + [SMALL_STATE(523)] = 39503, + [SMALL_STATE(524)] = 39534, + [SMALL_STATE(525)] = 39565, + [SMALL_STATE(526)] = 39596, + [SMALL_STATE(527)] = 39627, + [SMALL_STATE(528)] = 39685, + [SMALL_STATE(529)] = 39737, + [SMALL_STATE(530)] = 39795, + [SMALL_STATE(531)] = 39853, + [SMALL_STATE(532)] = 39911, + [SMALL_STATE(533)] = 39969, + [SMALL_STATE(534)] = 40027, + [SMALL_STATE(535)] = 40059, + [SMALL_STATE(536)] = 40117, + [SMALL_STATE(537)] = 40175, + [SMALL_STATE(538)] = 40233, + [SMALL_STATE(539)] = 40291, + [SMALL_STATE(540)] = 40349, + [SMALL_STATE(541)] = 40407, + [SMALL_STATE(542)] = 40465, + [SMALL_STATE(543)] = 40523, + [SMALL_STATE(544)] = 40581, + [SMALL_STATE(545)] = 40639, + [SMALL_STATE(546)] = 40691, + [SMALL_STATE(547)] = 40749, + [SMALL_STATE(548)] = 40807, + [SMALL_STATE(549)] = 40865, + [SMALL_STATE(550)] = 40923, + [SMALL_STATE(551)] = 40981, + [SMALL_STATE(552)] = 41039, + [SMALL_STATE(553)] = 41091, + [SMALL_STATE(554)] = 41143, + [SMALL_STATE(555)] = 41201, + [SMALL_STATE(556)] = 41259, + [SMALL_STATE(557)] = 41317, + [SMALL_STATE(558)] = 41375, + [SMALL_STATE(559)] = 41427, + [SMALL_STATE(560)] = 41481, + [SMALL_STATE(561)] = 41539, + [SMALL_STATE(562)] = 41597, + [SMALL_STATE(563)] = 41655, + [SMALL_STATE(564)] = 41713, + [SMALL_STATE(565)] = 41771, + [SMALL_STATE(566)] = 41829, + [SMALL_STATE(567)] = 41887, + [SMALL_STATE(568)] = 41945, + [SMALL_STATE(569)] = 42003, + [SMALL_STATE(570)] = 42061, + [SMALL_STATE(571)] = 42119, + [SMALL_STATE(572)] = 42177, + [SMALL_STATE(573)] = 42235, + [SMALL_STATE(574)] = 42293, + [SMALL_STATE(575)] = 42351, + [SMALL_STATE(576)] = 42403, + [SMALL_STATE(577)] = 42461, + [SMALL_STATE(578)] = 42519, + [SMALL_STATE(579)] = 42577, + [SMALL_STATE(580)] = 42635, + [SMALL_STATE(581)] = 42693, + [SMALL_STATE(582)] = 42751, + [SMALL_STATE(583)] = 42809, + [SMALL_STATE(584)] = 42861, + [SMALL_STATE(585)] = 42919, + [SMALL_STATE(586)] = 42977, + [SMALL_STATE(587)] = 43035, + [SMALL_STATE(588)] = 43093, + [SMALL_STATE(589)] = 43151, + [SMALL_STATE(590)] = 43209, + [SMALL_STATE(591)] = 43267, + [SMALL_STATE(592)] = 43325, + [SMALL_STATE(593)] = 43383, + [SMALL_STATE(594)] = 43441, + [SMALL_STATE(595)] = 43495, + [SMALL_STATE(596)] = 43553, + [SMALL_STATE(597)] = 43611, + [SMALL_STATE(598)] = 43669, + [SMALL_STATE(599)] = 43721, + [SMALL_STATE(600)] = 43779, + [SMALL_STATE(601)] = 43837, + [SMALL_STATE(602)] = 43895, + [SMALL_STATE(603)] = 43953, + [SMALL_STATE(604)] = 44011, + [SMALL_STATE(605)] = 44069, + [SMALL_STATE(606)] = 44127, + [SMALL_STATE(607)] = 44185, + [SMALL_STATE(608)] = 44243, + [SMALL_STATE(609)] = 44301, + [SMALL_STATE(610)] = 44359, + [SMALL_STATE(611)] = 44417, + [SMALL_STATE(612)] = 44446, + [SMALL_STATE(613)] = 44475, + [SMALL_STATE(614)] = 44530, + [SMALL_STATE(615)] = 44579, + [SMALL_STATE(616)] = 44628, + [SMALL_STATE(617)] = 44683, + [SMALL_STATE(618)] = 44712, + [SMALL_STATE(619)] = 44741, + [SMALL_STATE(620)] = 44796, + [SMALL_STATE(621)] = 44845, + [SMALL_STATE(622)] = 44874, + [SMALL_STATE(623)] = 44929, + [SMALL_STATE(624)] = 44968, + [SMALL_STATE(625)] = 45023, + [SMALL_STATE(626)] = 45078, + [SMALL_STATE(627)] = 45133, + [SMALL_STATE(628)] = 45181, + [SMALL_STATE(629)] = 45229, + [SMALL_STATE(630)] = 45277, + [SMALL_STATE(631)] = 45322, + [SMALL_STATE(632)] = 45355, + [SMALL_STATE(633)] = 45388, + [SMALL_STATE(634)] = 45433, + [SMALL_STATE(635)] = 45478, + [SMALL_STATE(636)] = 45526, + [SMALL_STATE(637)] = 45574, + [SMALL_STATE(638)] = 45622, + [SMALL_STATE(639)] = 45670, + [SMALL_STATE(640)] = 45718, + [SMALL_STATE(641)] = 45766, + [SMALL_STATE(642)] = 45814, + [SMALL_STATE(643)] = 45862, + [SMALL_STATE(644)] = 45910, + [SMALL_STATE(645)] = 45937, + [SMALL_STATE(646)] = 45963, + [SMALL_STATE(647)] = 45989, + [SMALL_STATE(648)] = 46015, + [SMALL_STATE(649)] = 46036, + [SMALL_STATE(650)] = 46067, + [SMALL_STATE(651)] = 46088, + [SMALL_STATE(652)] = 46115, + [SMALL_STATE(653)] = 46142, + [SMALL_STATE(654)] = 46167, + [SMALL_STATE(655)] = 46188, + [SMALL_STATE(656)] = 46213, + [SMALL_STATE(657)] = 46238, + [SMALL_STATE(658)] = 46263, + [SMALL_STATE(659)] = 46283, + [SMALL_STATE(660)] = 46303, + [SMALL_STATE(661)] = 46323, + [SMALL_STATE(662)] = 46357, + [SMALL_STATE(663)] = 46379, + [SMALL_STATE(664)] = 46399, + [SMALL_STATE(665)] = 46419, + [SMALL_STATE(666)] = 46441, + [SMALL_STATE(667)] = 46461, + [SMALL_STATE(668)] = 46495, + [SMALL_STATE(669)] = 46529, + [SMALL_STATE(670)] = 46549, + [SMALL_STATE(671)] = 46571, + [SMALL_STATE(672)] = 46591, + [SMALL_STATE(673)] = 46611, + [SMALL_STATE(674)] = 46631, + [SMALL_STATE(675)] = 46653, + [SMALL_STATE(676)] = 46687, + [SMALL_STATE(677)] = 46707, + [SMALL_STATE(678)] = 46727, + [SMALL_STATE(679)] = 46747, + [SMALL_STATE(680)] = 46767, + [SMALL_STATE(681)] = 46787, + [SMALL_STATE(682)] = 46807, + [SMALL_STATE(683)] = 46827, + [SMALL_STATE(684)] = 46847, + [SMALL_STATE(685)] = 46881, + [SMALL_STATE(686)] = 46915, + [SMALL_STATE(687)] = 46937, + [SMALL_STATE(688)] = 46971, + [SMALL_STATE(689)] = 47005, + [SMALL_STATE(690)] = 47024, + [SMALL_STATE(691)] = 47043, + [SMALL_STATE(692)] = 47062, + [SMALL_STATE(693)] = 47081, + [SMALL_STATE(694)] = 47100, + [SMALL_STATE(695)] = 47119, + [SMALL_STATE(696)] = 47138, + [SMALL_STATE(697)] = 47157, + [SMALL_STATE(698)] = 47176, + [SMALL_STATE(699)] = 47195, + [SMALL_STATE(700)] = 47214, + [SMALL_STATE(701)] = 47233, + [SMALL_STATE(702)] = 47252, + [SMALL_STATE(703)] = 47271, + [SMALL_STATE(704)] = 47290, + [SMALL_STATE(705)] = 47309, + [SMALL_STATE(706)] = 47328, + [SMALL_STATE(707)] = 47355, + [SMALL_STATE(708)] = 47374, + [SMALL_STATE(709)] = 47393, + [SMALL_STATE(710)] = 47412, + [SMALL_STATE(711)] = 47431, + [SMALL_STATE(712)] = 47450, + [SMALL_STATE(713)] = 47469, + [SMALL_STATE(714)] = 47488, + [SMALL_STATE(715)] = 47507, + [SMALL_STATE(716)] = 47526, + [SMALL_STATE(717)] = 47545, + [SMALL_STATE(718)] = 47564, + [SMALL_STATE(719)] = 47583, + [SMALL_STATE(720)] = 47602, + [SMALL_STATE(721)] = 47621, + [SMALL_STATE(722)] = 47640, + [SMALL_STATE(723)] = 47659, + [SMALL_STATE(724)] = 47678, + [SMALL_STATE(725)] = 47697, + [SMALL_STATE(726)] = 47716, + [SMALL_STATE(727)] = 47735, + [SMALL_STATE(728)] = 47754, + [SMALL_STATE(729)] = 47773, + [SMALL_STATE(730)] = 47792, + [SMALL_STATE(731)] = 47811, + [SMALL_STATE(732)] = 47830, + [SMALL_STATE(733)] = 47849, + [SMALL_STATE(734)] = 47868, + [SMALL_STATE(735)] = 47887, + [SMALL_STATE(736)] = 47906, + [SMALL_STATE(737)] = 47925, + [SMALL_STATE(738)] = 47944, + [SMALL_STATE(739)] = 47963, + [SMALL_STATE(740)] = 47982, + [SMALL_STATE(741)] = 48001, + [SMALL_STATE(742)] = 48020, + [SMALL_STATE(743)] = 48039, + [SMALL_STATE(744)] = 48058, + [SMALL_STATE(745)] = 48077, + [SMALL_STATE(746)] = 48096, + [SMALL_STATE(747)] = 48115, + [SMALL_STATE(748)] = 48134, + [SMALL_STATE(749)] = 48153, + [SMALL_STATE(750)] = 48172, + [SMALL_STATE(751)] = 48191, + [SMALL_STATE(752)] = 48210, + [SMALL_STATE(753)] = 48229, + [SMALL_STATE(754)] = 48248, + [SMALL_STATE(755)] = 48267, + [SMALL_STATE(756)] = 48286, + [SMALL_STATE(757)] = 48311, + [SMALL_STATE(758)] = 48330, + [SMALL_STATE(759)] = 48349, + [SMALL_STATE(760)] = 48368, + [SMALL_STATE(761)] = 48402, + [SMALL_STATE(762)] = 48436, + [SMALL_STATE(763)] = 48470, + [SMALL_STATE(764)] = 48494, + [SMALL_STATE(765)] = 48518, + [SMALL_STATE(766)] = 48552, + [SMALL_STATE(767)] = 48586, + [SMALL_STATE(768)] = 48616, + [SMALL_STATE(769)] = 48650, + [SMALL_STATE(770)] = 48674, + [SMALL_STATE(771)] = 48708, + [SMALL_STATE(772)] = 48742, + [SMALL_STATE(773)] = 48776, + [SMALL_STATE(774)] = 48810, + [SMALL_STATE(775)] = 48832, + [SMALL_STATE(776)] = 48854, + [SMALL_STATE(777)] = 48888, + [SMALL_STATE(778)] = 48922, + [SMALL_STATE(779)] = 48956, + [SMALL_STATE(780)] = 48990, + [SMALL_STATE(781)] = 49024, + [SMALL_STATE(782)] = 49058, + [SMALL_STATE(783)] = 49082, + [SMALL_STATE(784)] = 49116, + [SMALL_STATE(785)] = 49150, + [SMALL_STATE(786)] = 49184, + [SMALL_STATE(787)] = 49218, + [SMALL_STATE(788)] = 49252, + [SMALL_STATE(789)] = 49286, + [SMALL_STATE(790)] = 49320, + [SMALL_STATE(791)] = 49344, + [SMALL_STATE(792)] = 49378, + [SMALL_STATE(793)] = 49412, + [SMALL_STATE(794)] = 49446, + [SMALL_STATE(795)] = 49480, + [SMALL_STATE(796)] = 49514, + [SMALL_STATE(797)] = 49548, + [SMALL_STATE(798)] = 49582, + [SMALL_STATE(799)] = 49616, + [SMALL_STATE(800)] = 49638, + [SMALL_STATE(801)] = 49660, + [SMALL_STATE(802)] = 49694, + [SMALL_STATE(803)] = 49728, + [SMALL_STATE(804)] = 49749, + [SMALL_STATE(805)] = 49770, + [SMALL_STATE(806)] = 49791, + [SMALL_STATE(807)] = 49810, + [SMALL_STATE(808)] = 49831, + [SMALL_STATE(809)] = 49848, + [SMALL_STATE(810)] = 49867, + [SMALL_STATE(811)] = 49888, + [SMALL_STATE(812)] = 49917, + [SMALL_STATE(813)] = 49952, + [SMALL_STATE(814)] = 49971, + [SMALL_STATE(815)] = 49992, + [SMALL_STATE(816)] = 50013, + [SMALL_STATE(817)] = 50040, + [SMALL_STATE(818)] = 50059, + [SMALL_STATE(819)] = 50088, + [SMALL_STATE(820)] = 50107, + [SMALL_STATE(821)] = 50136, + [SMALL_STATE(822)] = 50165, + [SMALL_STATE(823)] = 50194, + [SMALL_STATE(824)] = 50213, + [SMALL_STATE(825)] = 50242, + [SMALL_STATE(826)] = 50268, + [SMALL_STATE(827)] = 50286, + [SMALL_STATE(828)] = 50306, + [SMALL_STATE(829)] = 50332, + [SMALL_STATE(830)] = 50360, + [SMALL_STATE(831)] = 50386, + [SMALL_STATE(832)] = 50420, + [SMALL_STATE(833)] = 50446, + [SMALL_STATE(834)] = 50472, + [SMALL_STATE(835)] = 50498, + [SMALL_STATE(836)] = 50524, + [SMALL_STATE(837)] = 50550, + [SMALL_STATE(838)] = 50568, + [SMALL_STATE(839)] = 50586, + [SMALL_STATE(840)] = 50618, + [SMALL_STATE(841)] = 50633, + [SMALL_STATE(842)] = 50656, + [SMALL_STATE(843)] = 50679, + [SMALL_STATE(844)] = 50702, + [SMALL_STATE(845)] = 50725, + [SMALL_STATE(846)] = 50748, + [SMALL_STATE(847)] = 50771, + [SMALL_STATE(848)] = 50786, + [SMALL_STATE(849)] = 50809, + [SMALL_STATE(850)] = 50824, + [SMALL_STATE(851)] = 50847, + [SMALL_STATE(852)] = 50862, + [SMALL_STATE(853)] = 50885, + [SMALL_STATE(854)] = 50908, + [SMALL_STATE(855)] = 50931, + [SMALL_STATE(856)] = 50954, + [SMALL_STATE(857)] = 50977, + [SMALL_STATE(858)] = 51000, + [SMALL_STATE(859)] = 51023, + [SMALL_STATE(860)] = 51046, + [SMALL_STATE(861)] = 51069, + [SMALL_STATE(862)] = 51092, + [SMALL_STATE(863)] = 51111, + [SMALL_STATE(864)] = 51134, + [SMALL_STATE(865)] = 51153, + [SMALL_STATE(866)] = 51176, + [SMALL_STATE(867)] = 51199, + [SMALL_STATE(868)] = 51222, + [SMALL_STATE(869)] = 51245, + [SMALL_STATE(870)] = 51260, + [SMALL_STATE(871)] = 51283, + [SMALL_STATE(872)] = 51306, + [SMALL_STATE(873)] = 51321, + [SMALL_STATE(874)] = 51344, + [SMALL_STATE(875)] = 51367, + [SMALL_STATE(876)] = 51390, + [SMALL_STATE(877)] = 51413, + [SMALL_STATE(878)] = 51436, + [SMALL_STATE(879)] = 51459, + [SMALL_STATE(880)] = 51474, + [SMALL_STATE(881)] = 51497, + [SMALL_STATE(882)] = 51512, + [SMALL_STATE(883)] = 51535, + [SMALL_STATE(884)] = 51550, + [SMALL_STATE(885)] = 51565, + [SMALL_STATE(886)] = 51588, + [SMALL_STATE(887)] = 51603, + [SMALL_STATE(888)] = 51626, + [SMALL_STATE(889)] = 51649, + [SMALL_STATE(890)] = 51672, + [SMALL_STATE(891)] = 51695, + [SMALL_STATE(892)] = 51710, + [SMALL_STATE(893)] = 51725, + [SMALL_STATE(894)] = 51740, + [SMALL_STATE(895)] = 51763, + [SMALL_STATE(896)] = 51786, + [SMALL_STATE(897)] = 51809, + [SMALL_STATE(898)] = 51824, + [SMALL_STATE(899)] = 51847, + [SMALL_STATE(900)] = 51870, + [SMALL_STATE(901)] = 51893, + [SMALL_STATE(902)] = 51916, + [SMALL_STATE(903)] = 51939, + [SMALL_STATE(904)] = 51962, + [SMALL_STATE(905)] = 51985, + [SMALL_STATE(906)] = 52008, + [SMALL_STATE(907)] = 52023, + [SMALL_STATE(908)] = 52046, + [SMALL_STATE(909)] = 52061, + [SMALL_STATE(910)] = 52076, + [SMALL_STATE(911)] = 52099, + [SMALL_STATE(912)] = 52122, + [SMALL_STATE(913)] = 52137, + [SMALL_STATE(914)] = 52160, + [SMALL_STATE(915)] = 52175, + [SMALL_STATE(916)] = 52198, + [SMALL_STATE(917)] = 52221, + [SMALL_STATE(918)] = 52244, + [SMALL_STATE(919)] = 52267, + [SMALL_STATE(920)] = 52290, + [SMALL_STATE(921)] = 52313, + [SMALL_STATE(922)] = 52336, + [SMALL_STATE(923)] = 52363, + [SMALL_STATE(924)] = 52386, + [SMALL_STATE(925)] = 52409, + [SMALL_STATE(926)] = 52432, + [SMALL_STATE(927)] = 52455, + [SMALL_STATE(928)] = 52478, + [SMALL_STATE(929)] = 52501, + [SMALL_STATE(930)] = 52524, + [SMALL_STATE(931)] = 52547, + [SMALL_STATE(932)] = 52570, + [SMALL_STATE(933)] = 52593, + [SMALL_STATE(934)] = 52616, + [SMALL_STATE(935)] = 52639, + [SMALL_STATE(936)] = 52662, + [SMALL_STATE(937)] = 52685, + [SMALL_STATE(938)] = 52708, + [SMALL_STATE(939)] = 52731, + [SMALL_STATE(940)] = 52754, + [SMALL_STATE(941)] = 52768, + [SMALL_STATE(942)] = 52790, + [SMALL_STATE(943)] = 52811, + [SMALL_STATE(944)] = 52826, + [SMALL_STATE(945)] = 52841, + [SMALL_STATE(946)] = 52862, + [SMALL_STATE(947)] = 52877, + [SMALL_STATE(948)] = 52892, + [SMALL_STATE(949)] = 52907, + [SMALL_STATE(950)] = 52928, + [SMALL_STATE(951)] = 52949, + [SMALL_STATE(952)] = 52970, + [SMALL_STATE(953)] = 52985, + [SMALL_STATE(954)] = 53008, + [SMALL_STATE(955)] = 53023, + [SMALL_STATE(956)] = 53046, + [SMALL_STATE(957)] = 53069, + [SMALL_STATE(958)] = 53090, + [SMALL_STATE(959)] = 53105, + [SMALL_STATE(960)] = 53120, + [SMALL_STATE(961)] = 53135, + [SMALL_STATE(962)] = 53156, + [SMALL_STATE(963)] = 53171, + [SMALL_STATE(964)] = 53186, + [SMALL_STATE(965)] = 53201, + [SMALL_STATE(966)] = 53224, + [SMALL_STATE(967)] = 53239, + [SMALL_STATE(968)] = 53262, + [SMALL_STATE(969)] = 53283, + [SMALL_STATE(970)] = 53306, + [SMALL_STATE(971)] = 53321, + [SMALL_STATE(972)] = 53336, + [SMALL_STATE(973)] = 53358, + [SMALL_STATE(974)] = 53380, + [SMALL_STATE(975)] = 53402, + [SMALL_STATE(976)] = 53424, + [SMALL_STATE(977)] = 53446, + [SMALL_STATE(978)] = 53468, + [SMALL_STATE(979)] = 53484, + [SMALL_STATE(980)] = 53506, + [SMALL_STATE(981)] = 53518, + [SMALL_STATE(982)] = 53540, + [SMALL_STATE(983)] = 53562, + [SMALL_STATE(984)] = 53576, + [SMALL_STATE(985)] = 53596, + [SMALL_STATE(986)] = 53618, + [SMALL_STATE(987)] = 53640, + [SMALL_STATE(988)] = 53662, + [SMALL_STATE(989)] = 53684, + [SMALL_STATE(990)] = 53706, + [SMALL_STATE(991)] = 53728, + [SMALL_STATE(992)] = 53746, + [SMALL_STATE(993)] = 53768, + [SMALL_STATE(994)] = 53785, + [SMALL_STATE(995)] = 53802, + [SMALL_STATE(996)] = 53819, + [SMALL_STATE(997)] = 53836, + [SMALL_STATE(998)] = 53851, + [SMALL_STATE(999)] = 53870, + [SMALL_STATE(1000)] = 53887, + [SMALL_STATE(1001)] = 53904, + [SMALL_STATE(1002)] = 53919, + [SMALL_STATE(1003)] = 53934, + [SMALL_STATE(1004)] = 53949, + [SMALL_STATE(1005)] = 53968, + [SMALL_STATE(1006)] = 53985, + [SMALL_STATE(1007)] = 54000, + [SMALL_STATE(1008)] = 54017, + [SMALL_STATE(1009)] = 54034, + [SMALL_STATE(1010)] = 54049, + [SMALL_STATE(1011)] = 54066, + [SMALL_STATE(1012)] = 54083, + [SMALL_STATE(1013)] = 54102, + [SMALL_STATE(1014)] = 54121, + [SMALL_STATE(1015)] = 54138, + [SMALL_STATE(1016)] = 54157, + [SMALL_STATE(1017)] = 54176, + [SMALL_STATE(1018)] = 54195, + [SMALL_STATE(1019)] = 54212, + [SMALL_STATE(1020)] = 54231, + [SMALL_STATE(1021)] = 54250, + [SMALL_STATE(1022)] = 54267, + [SMALL_STATE(1023)] = 54286, + [SMALL_STATE(1024)] = 54305, + [SMALL_STATE(1025)] = 54324, + [SMALL_STATE(1026)] = 54343, + [SMALL_STATE(1027)] = 54362, + [SMALL_STATE(1028)] = 54377, + [SMALL_STATE(1029)] = 54394, + [SMALL_STATE(1030)] = 54409, + [SMALL_STATE(1031)] = 54424, + [SMALL_STATE(1032)] = 54439, + [SMALL_STATE(1033)] = 54456, + [SMALL_STATE(1034)] = 54475, + [SMALL_STATE(1035)] = 54490, + [SMALL_STATE(1036)] = 54507, + [SMALL_STATE(1037)] = 54524, + [SMALL_STATE(1038)] = 54539, + [SMALL_STATE(1039)] = 54556, + [SMALL_STATE(1040)] = 54573, + [SMALL_STATE(1041)] = 54588, + [SMALL_STATE(1042)] = 54603, + [SMALL_STATE(1043)] = 54620, + [SMALL_STATE(1044)] = 54637, + [SMALL_STATE(1045)] = 54654, + [SMALL_STATE(1046)] = 54671, + [SMALL_STATE(1047)] = 54688, + [SMALL_STATE(1048)] = 54703, + [SMALL_STATE(1049)] = 54720, + [SMALL_STATE(1050)] = 54739, + [SMALL_STATE(1051)] = 54756, + [SMALL_STATE(1052)] = 54773, + [SMALL_STATE(1053)] = 54790, + [SMALL_STATE(1054)] = 54809, + [SMALL_STATE(1055)] = 54826, + [SMALL_STATE(1056)] = 54843, + [SMALL_STATE(1057)] = 54860, + [SMALL_STATE(1058)] = 54879, + [SMALL_STATE(1059)] = 54896, + [SMALL_STATE(1060)] = 54913, + [SMALL_STATE(1061)] = 54930, + [SMALL_STATE(1062)] = 54949, + [SMALL_STATE(1063)] = 54968, + [SMALL_STATE(1064)] = 54985, + [SMALL_STATE(1065)] = 55002, + [SMALL_STATE(1066)] = 55019, + [SMALL_STATE(1067)] = 55038, + [SMALL_STATE(1068)] = 55057, + [SMALL_STATE(1069)] = 55074, + [SMALL_STATE(1070)] = 55091, + [SMALL_STATE(1071)] = 55108, + [SMALL_STATE(1072)] = 55118, + [SMALL_STATE(1073)] = 55132, + [SMALL_STATE(1074)] = 55142, + [SMALL_STATE(1075)] = 55156, + [SMALL_STATE(1076)] = 55166, + [SMALL_STATE(1077)] = 55176, + [SMALL_STATE(1078)] = 55186, + [SMALL_STATE(1079)] = 55196, + [SMALL_STATE(1080)] = 55206, + [SMALL_STATE(1081)] = 55222, + [SMALL_STATE(1082)] = 55236, + [SMALL_STATE(1083)] = 55252, + [SMALL_STATE(1084)] = 55262, + [SMALL_STATE(1085)] = 55278, + [SMALL_STATE(1086)] = 55288, + [SMALL_STATE(1087)] = 55304, + [SMALL_STATE(1088)] = 55314, + [SMALL_STATE(1089)] = 55328, + [SMALL_STATE(1090)] = 55342, + [SMALL_STATE(1091)] = 55358, + [SMALL_STATE(1092)] = 55372, + [SMALL_STATE(1093)] = 55386, + [SMALL_STATE(1094)] = 55400, + [SMALL_STATE(1095)] = 55412, + [SMALL_STATE(1096)] = 55426, + [SMALL_STATE(1097)] = 55442, + [SMALL_STATE(1098)] = 55456, + [SMALL_STATE(1099)] = 55466, + [SMALL_STATE(1100)] = 55480, + [SMALL_STATE(1101)] = 55494, + [SMALL_STATE(1102)] = 55508, + [SMALL_STATE(1103)] = 55524, + [SMALL_STATE(1104)] = 55540, + [SMALL_STATE(1105)] = 55556, + [SMALL_STATE(1106)] = 55566, + [SMALL_STATE(1107)] = 55580, + [SMALL_STATE(1108)] = 55590, + [SMALL_STATE(1109)] = 55604, + [SMALL_STATE(1110)] = 55620, + [SMALL_STATE(1111)] = 55636, + [SMALL_STATE(1112)] = 55646, + [SMALL_STATE(1113)] = 55662, + [SMALL_STATE(1114)] = 55676, + [SMALL_STATE(1115)] = 55690, + [SMALL_STATE(1116)] = 55704, + [SMALL_STATE(1117)] = 55718, + [SMALL_STATE(1118)] = 55728, + [SMALL_STATE(1119)] = 55744, + [SMALL_STATE(1120)] = 55754, + [SMALL_STATE(1121)] = 55770, + [SMALL_STATE(1122)] = 55783, + [SMALL_STATE(1123)] = 55796, + [SMALL_STATE(1124)] = 55809, + [SMALL_STATE(1125)] = 55822, + [SMALL_STATE(1126)] = 55835, + [SMALL_STATE(1127)] = 55848, + [SMALL_STATE(1128)] = 55861, + [SMALL_STATE(1129)] = 55874, + [SMALL_STATE(1130)] = 55887, + [SMALL_STATE(1131)] = 55900, + [SMALL_STATE(1132)] = 55913, + [SMALL_STATE(1133)] = 55926, + [SMALL_STATE(1134)] = 55939, + [SMALL_STATE(1135)] = 55952, + [SMALL_STATE(1136)] = 55965, + [SMALL_STATE(1137)] = 55978, + [SMALL_STATE(1138)] = 55991, + [SMALL_STATE(1139)] = 56004, + [SMALL_STATE(1140)] = 56017, + [SMALL_STATE(1141)] = 56030, + [SMALL_STATE(1142)] = 56043, + [SMALL_STATE(1143)] = 56056, + [SMALL_STATE(1144)] = 56069, + [SMALL_STATE(1145)] = 56082, + [SMALL_STATE(1146)] = 56095, + [SMALL_STATE(1147)] = 56108, + [SMALL_STATE(1148)] = 56121, + [SMALL_STATE(1149)] = 56134, + [SMALL_STATE(1150)] = 56147, + [SMALL_STATE(1151)] = 56160, + [SMALL_STATE(1152)] = 56169, + [SMALL_STATE(1153)] = 56182, + [SMALL_STATE(1154)] = 56195, + [SMALL_STATE(1155)] = 56208, + [SMALL_STATE(1156)] = 56221, + [SMALL_STATE(1157)] = 56234, + [SMALL_STATE(1158)] = 56247, + [SMALL_STATE(1159)] = 56260, + [SMALL_STATE(1160)] = 56273, + [SMALL_STATE(1161)] = 56284, + [SMALL_STATE(1162)] = 56297, + [SMALL_STATE(1163)] = 56308, + [SMALL_STATE(1164)] = 56321, + [SMALL_STATE(1165)] = 56332, + [SMALL_STATE(1166)] = 56343, + [SMALL_STATE(1167)] = 56356, + [SMALL_STATE(1168)] = 56369, + [SMALL_STATE(1169)] = 56382, + [SMALL_STATE(1170)] = 56395, + [SMALL_STATE(1171)] = 56404, + [SMALL_STATE(1172)] = 56417, + [SMALL_STATE(1173)] = 56426, + [SMALL_STATE(1174)] = 56439, + [SMALL_STATE(1175)] = 56452, + [SMALL_STATE(1176)] = 56465, + [SMALL_STATE(1177)] = 56478, + [SMALL_STATE(1178)] = 56491, + [SMALL_STATE(1179)] = 56504, + [SMALL_STATE(1180)] = 56517, + [SMALL_STATE(1181)] = 56526, + [SMALL_STATE(1182)] = 56539, + [SMALL_STATE(1183)] = 56550, + [SMALL_STATE(1184)] = 56563, + [SMALL_STATE(1185)] = 56574, + [SMALL_STATE(1186)] = 56587, + [SMALL_STATE(1187)] = 56600, + [SMALL_STATE(1188)] = 56613, + [SMALL_STATE(1189)] = 56626, + [SMALL_STATE(1190)] = 56637, + [SMALL_STATE(1191)] = 56646, + [SMALL_STATE(1192)] = 56659, + [SMALL_STATE(1193)] = 56672, + [SMALL_STATE(1194)] = 56685, + [SMALL_STATE(1195)] = 56698, + [SMALL_STATE(1196)] = 56711, + [SMALL_STATE(1197)] = 56724, + [SMALL_STATE(1198)] = 56737, + [SMALL_STATE(1199)] = 56750, + [SMALL_STATE(1200)] = 56763, + [SMALL_STATE(1201)] = 56776, + [SMALL_STATE(1202)] = 56789, + [SMALL_STATE(1203)] = 56798, + [SMALL_STATE(1204)] = 56811, + [SMALL_STATE(1205)] = 56822, + [SMALL_STATE(1206)] = 56835, + [SMALL_STATE(1207)] = 56848, + [SMALL_STATE(1208)] = 56861, + [SMALL_STATE(1209)] = 56874, + [SMALL_STATE(1210)] = 56887, + [SMALL_STATE(1211)] = 56900, + [SMALL_STATE(1212)] = 56913, + [SMALL_STATE(1213)] = 56926, + [SMALL_STATE(1214)] = 56939, + [SMALL_STATE(1215)] = 56952, + [SMALL_STATE(1216)] = 56963, + [SMALL_STATE(1217)] = 56976, + [SMALL_STATE(1218)] = 56989, + [SMALL_STATE(1219)] = 57002, + [SMALL_STATE(1220)] = 57015, + [SMALL_STATE(1221)] = 57026, + [SMALL_STATE(1222)] = 57039, + [SMALL_STATE(1223)] = 57052, + [SMALL_STATE(1224)] = 57065, + [SMALL_STATE(1225)] = 57078, + [SMALL_STATE(1226)] = 57091, + [SMALL_STATE(1227)] = 57104, + [SMALL_STATE(1228)] = 57117, + [SMALL_STATE(1229)] = 57128, + [SMALL_STATE(1230)] = 57141, + [SMALL_STATE(1231)] = 57154, + [SMALL_STATE(1232)] = 57163, + [SMALL_STATE(1233)] = 57174, + [SMALL_STATE(1234)] = 57187, + [SMALL_STATE(1235)] = 57200, + [SMALL_STATE(1236)] = 57213, + [SMALL_STATE(1237)] = 57226, + [SMALL_STATE(1238)] = 57239, + [SMALL_STATE(1239)] = 57252, + [SMALL_STATE(1240)] = 57265, + [SMALL_STATE(1241)] = 57278, + [SMALL_STATE(1242)] = 57291, + [SMALL_STATE(1243)] = 57304, + [SMALL_STATE(1244)] = 57317, + [SMALL_STATE(1245)] = 57330, + [SMALL_STATE(1246)] = 57343, + [SMALL_STATE(1247)] = 57356, + [SMALL_STATE(1248)] = 57369, + [SMALL_STATE(1249)] = 57382, + [SMALL_STATE(1250)] = 57395, + [SMALL_STATE(1251)] = 57404, + [SMALL_STATE(1252)] = 57417, + [SMALL_STATE(1253)] = 57430, + [SMALL_STATE(1254)] = 57443, + [SMALL_STATE(1255)] = 57456, + [SMALL_STATE(1256)] = 57469, + [SMALL_STATE(1257)] = 57482, + [SMALL_STATE(1258)] = 57495, + [SMALL_STATE(1259)] = 57508, + [SMALL_STATE(1260)] = 57521, + [SMALL_STATE(1261)] = 57534, + [SMALL_STATE(1262)] = 57547, + [SMALL_STATE(1263)] = 57558, + [SMALL_STATE(1264)] = 57571, + [SMALL_STATE(1265)] = 57584, + [SMALL_STATE(1266)] = 57597, + [SMALL_STATE(1267)] = 57610, + [SMALL_STATE(1268)] = 57623, + [SMALL_STATE(1269)] = 57634, + [SMALL_STATE(1270)] = 57647, + [SMALL_STATE(1271)] = 57657, + [SMALL_STATE(1272)] = 57667, + [SMALL_STATE(1273)] = 57677, + [SMALL_STATE(1274)] = 57685, + [SMALL_STATE(1275)] = 57693, + [SMALL_STATE(1276)] = 57701, + [SMALL_STATE(1277)] = 57709, + [SMALL_STATE(1278)] = 57719, + [SMALL_STATE(1279)] = 57729, + [SMALL_STATE(1280)] = 57739, + [SMALL_STATE(1281)] = 57747, + [SMALL_STATE(1282)] = 57755, + [SMALL_STATE(1283)] = 57765, + [SMALL_STATE(1284)] = 57775, + [SMALL_STATE(1285)] = 57783, + [SMALL_STATE(1286)] = 57791, + [SMALL_STATE(1287)] = 57799, + [SMALL_STATE(1288)] = 57809, + [SMALL_STATE(1289)] = 57819, + [SMALL_STATE(1290)] = 57829, + [SMALL_STATE(1291)] = 57839, + [SMALL_STATE(1292)] = 57847, + [SMALL_STATE(1293)] = 57857, + [SMALL_STATE(1294)] = 57867, + [SMALL_STATE(1295)] = 57877, + [SMALL_STATE(1296)] = 57887, + [SMALL_STATE(1297)] = 57895, + [SMALL_STATE(1298)] = 57905, + [SMALL_STATE(1299)] = 57915, + [SMALL_STATE(1300)] = 57925, + [SMALL_STATE(1301)] = 57935, + [SMALL_STATE(1302)] = 57945, + [SMALL_STATE(1303)] = 57955, + [SMALL_STATE(1304)] = 57965, + [SMALL_STATE(1305)] = 57975, + [SMALL_STATE(1306)] = 57985, + [SMALL_STATE(1307)] = 57993, + [SMALL_STATE(1308)] = 58001, + [SMALL_STATE(1309)] = 58009, + [SMALL_STATE(1310)] = 58019, + [SMALL_STATE(1311)] = 58027, + [SMALL_STATE(1312)] = 58037, + [SMALL_STATE(1313)] = 58045, + [SMALL_STATE(1314)] = 58053, + [SMALL_STATE(1315)] = 58061, + [SMALL_STATE(1316)] = 58071, + [SMALL_STATE(1317)] = 58081, + [SMALL_STATE(1318)] = 58091, + [SMALL_STATE(1319)] = 58101, + [SMALL_STATE(1320)] = 58109, + [SMALL_STATE(1321)] = 58119, + [SMALL_STATE(1322)] = 58129, + [SMALL_STATE(1323)] = 58139, + [SMALL_STATE(1324)] = 58149, + [SMALL_STATE(1325)] = 58157, + [SMALL_STATE(1326)] = 58165, + [SMALL_STATE(1327)] = 58175, + [SMALL_STATE(1328)] = 58185, + [SMALL_STATE(1329)] = 58195, + [SMALL_STATE(1330)] = 58203, + [SMALL_STATE(1331)] = 58213, + [SMALL_STATE(1332)] = 58223, + [SMALL_STATE(1333)] = 58233, + [SMALL_STATE(1334)] = 58243, + [SMALL_STATE(1335)] = 58253, + [SMALL_STATE(1336)] = 58263, + [SMALL_STATE(1337)] = 58273, + [SMALL_STATE(1338)] = 58281, + [SMALL_STATE(1339)] = 58291, + [SMALL_STATE(1340)] = 58301, + [SMALL_STATE(1341)] = 58309, + [SMALL_STATE(1342)] = 58319, + [SMALL_STATE(1343)] = 58329, + [SMALL_STATE(1344)] = 58339, + [SMALL_STATE(1345)] = 58349, + [SMALL_STATE(1346)] = 58357, + [SMALL_STATE(1347)] = 58367, + [SMALL_STATE(1348)] = 58375, + [SMALL_STATE(1349)] = 58385, + [SMALL_STATE(1350)] = 58393, + [SMALL_STATE(1351)] = 58403, + [SMALL_STATE(1352)] = 58411, + [SMALL_STATE(1353)] = 58421, + [SMALL_STATE(1354)] = 58431, + [SMALL_STATE(1355)] = 58441, + [SMALL_STATE(1356)] = 58451, + [SMALL_STATE(1357)] = 58461, + [SMALL_STATE(1358)] = 58471, + [SMALL_STATE(1359)] = 58481, + [SMALL_STATE(1360)] = 58491, + [SMALL_STATE(1361)] = 58501, + [SMALL_STATE(1362)] = 58511, + [SMALL_STATE(1363)] = 58519, + [SMALL_STATE(1364)] = 58527, + [SMALL_STATE(1365)] = 58537, + [SMALL_STATE(1366)] = 58545, + [SMALL_STATE(1367)] = 58555, + [SMALL_STATE(1368)] = 58565, + [SMALL_STATE(1369)] = 58575, + [SMALL_STATE(1370)] = 58585, + [SMALL_STATE(1371)] = 58592, + [SMALL_STATE(1372)] = 58599, + [SMALL_STATE(1373)] = 58606, + [SMALL_STATE(1374)] = 58613, + [SMALL_STATE(1375)] = 58620, + [SMALL_STATE(1376)] = 58627, + [SMALL_STATE(1377)] = 58634, + [SMALL_STATE(1378)] = 58641, + [SMALL_STATE(1379)] = 58648, + [SMALL_STATE(1380)] = 58655, + [SMALL_STATE(1381)] = 58662, + [SMALL_STATE(1382)] = 58669, + [SMALL_STATE(1383)] = 58676, + [SMALL_STATE(1384)] = 58683, + [SMALL_STATE(1385)] = 58690, + [SMALL_STATE(1386)] = 58697, + [SMALL_STATE(1387)] = 58704, + [SMALL_STATE(1388)] = 58711, + [SMALL_STATE(1389)] = 58718, + [SMALL_STATE(1390)] = 58725, + [SMALL_STATE(1391)] = 58732, + [SMALL_STATE(1392)] = 58739, + [SMALL_STATE(1393)] = 58746, + [SMALL_STATE(1394)] = 58753, + [SMALL_STATE(1395)] = 58760, + [SMALL_STATE(1396)] = 58767, + [SMALL_STATE(1397)] = 58774, + [SMALL_STATE(1398)] = 58781, + [SMALL_STATE(1399)] = 58788, + [SMALL_STATE(1400)] = 58795, + [SMALL_STATE(1401)] = 58802, + [SMALL_STATE(1402)] = 58809, + [SMALL_STATE(1403)] = 58816, + [SMALL_STATE(1404)] = 58823, + [SMALL_STATE(1405)] = 58830, + [SMALL_STATE(1406)] = 58837, + [SMALL_STATE(1407)] = 58844, + [SMALL_STATE(1408)] = 58851, + [SMALL_STATE(1409)] = 58858, + [SMALL_STATE(1410)] = 58865, + [SMALL_STATE(1411)] = 58872, + [SMALL_STATE(1412)] = 58879, + [SMALL_STATE(1413)] = 58886, + [SMALL_STATE(1414)] = 58893, + [SMALL_STATE(1415)] = 58900, + [SMALL_STATE(1416)] = 58907, + [SMALL_STATE(1417)] = 58914, + [SMALL_STATE(1418)] = 58921, + [SMALL_STATE(1419)] = 58928, + [SMALL_STATE(1420)] = 58935, + [SMALL_STATE(1421)] = 58942, + [SMALL_STATE(1422)] = 58949, + [SMALL_STATE(1423)] = 58956, + [SMALL_STATE(1424)] = 58963, + [SMALL_STATE(1425)] = 58970, + [SMALL_STATE(1426)] = 58977, + [SMALL_STATE(1427)] = 58984, + [SMALL_STATE(1428)] = 58991, + [SMALL_STATE(1429)] = 58998, + [SMALL_STATE(1430)] = 59005, + [SMALL_STATE(1431)] = 59012, + [SMALL_STATE(1432)] = 59019, + [SMALL_STATE(1433)] = 59026, + [SMALL_STATE(1434)] = 59033, + [SMALL_STATE(1435)] = 59040, + [SMALL_STATE(1436)] = 59047, + [SMALL_STATE(1437)] = 59054, + [SMALL_STATE(1438)] = 59061, + [SMALL_STATE(1439)] = 59068, + [SMALL_STATE(1440)] = 59075, + [SMALL_STATE(1441)] = 59082, + [SMALL_STATE(1442)] = 59089, + [SMALL_STATE(1443)] = 59096, + [SMALL_STATE(1444)] = 59103, + [SMALL_STATE(1445)] = 59110, + [SMALL_STATE(1446)] = 59117, + [SMALL_STATE(1447)] = 59124, + [SMALL_STATE(1448)] = 59131, + [SMALL_STATE(1449)] = 59138, + [SMALL_STATE(1450)] = 59145, + [SMALL_STATE(1451)] = 59152, + [SMALL_STATE(1452)] = 59159, + [SMALL_STATE(1453)] = 59166, + [SMALL_STATE(1454)] = 59173, + [SMALL_STATE(1455)] = 59180, + [SMALL_STATE(1456)] = 59187, + [SMALL_STATE(1457)] = 59194, + [SMALL_STATE(1458)] = 59201, + [SMALL_STATE(1459)] = 59208, + [SMALL_STATE(1460)] = 59215, + [SMALL_STATE(1461)] = 59222, + [SMALL_STATE(1462)] = 59229, + [SMALL_STATE(1463)] = 59236, + [SMALL_STATE(1464)] = 59243, + [SMALL_STATE(1465)] = 59250, + [SMALL_STATE(1466)] = 59257, + [SMALL_STATE(1467)] = 59264, + [SMALL_STATE(1468)] = 59271, + [SMALL_STATE(1469)] = 59278, + [SMALL_STATE(1470)] = 59285, + [SMALL_STATE(1471)] = 59292, + [SMALL_STATE(1472)] = 59299, + [SMALL_STATE(1473)] = 59306, + [SMALL_STATE(1474)] = 59313, + [SMALL_STATE(1475)] = 59320, + [SMALL_STATE(1476)] = 59327, + [SMALL_STATE(1477)] = 59334, + [SMALL_STATE(1478)] = 59341, + [SMALL_STATE(1479)] = 59348, + [SMALL_STATE(1480)] = 59355, + [SMALL_STATE(1481)] = 59362, + [SMALL_STATE(1482)] = 59369, + [SMALL_STATE(1483)] = 59376, + [SMALL_STATE(1484)] = 59383, + [SMALL_STATE(1485)] = 59390, + [SMALL_STATE(1486)] = 59397, + [SMALL_STATE(1487)] = 59404, + [SMALL_STATE(1488)] = 59411, + [SMALL_STATE(1489)] = 59418, + [SMALL_STATE(1490)] = 59425, + [SMALL_STATE(1491)] = 59432, + [SMALL_STATE(1492)] = 59439, + [SMALL_STATE(1493)] = 59446, + [SMALL_STATE(1494)] = 59453, + [SMALL_STATE(1495)] = 59460, + [SMALL_STATE(1496)] = 59467, + [SMALL_STATE(1497)] = 59474, + [SMALL_STATE(1498)] = 59481, + [SMALL_STATE(1499)] = 59488, + [SMALL_STATE(1500)] = 59495, + [SMALL_STATE(1501)] = 59502, + [SMALL_STATE(1502)] = 59509, + [SMALL_STATE(1503)] = 59516, + [SMALL_STATE(1504)] = 59523, + [SMALL_STATE(1505)] = 59530, + [SMALL_STATE(1506)] = 59537, + [SMALL_STATE(1507)] = 59544, + [SMALL_STATE(1508)] = 59551, + [SMALL_STATE(1509)] = 59558, + [SMALL_STATE(1510)] = 59565, + [SMALL_STATE(1511)] = 59572, + [SMALL_STATE(1512)] = 59579, + [SMALL_STATE(1513)] = 59586, + [SMALL_STATE(1514)] = 59593, + [SMALL_STATE(1515)] = 59600, + [SMALL_STATE(1516)] = 59607, + [SMALL_STATE(1517)] = 59614, + [SMALL_STATE(1518)] = 59621, + [SMALL_STATE(1519)] = 59628, + [SMALL_STATE(1520)] = 59635, + [SMALL_STATE(1521)] = 59642, + [SMALL_STATE(1522)] = 59649, + [SMALL_STATE(1523)] = 59656, + [SMALL_STATE(1524)] = 59663, + [SMALL_STATE(1525)] = 59670, + [SMALL_STATE(1526)] = 59677, + [SMALL_STATE(1527)] = 59684, + [SMALL_STATE(1528)] = 59691, + [SMALL_STATE(1529)] = 59698, + [SMALL_STATE(1530)] = 59705, + [SMALL_STATE(1531)] = 59712, + [SMALL_STATE(1532)] = 59719, + [SMALL_STATE(1533)] = 59726, + [SMALL_STATE(1534)] = 59733, + [SMALL_STATE(1535)] = 59740, + [SMALL_STATE(1536)] = 59747, + [SMALL_STATE(1537)] = 59754, + [SMALL_STATE(1538)] = 59761, + [SMALL_STATE(1539)] = 59768, + [SMALL_STATE(1540)] = 59775, + [SMALL_STATE(1541)] = 59782, + [SMALL_STATE(1542)] = 59789, + [SMALL_STATE(1543)] = 59796, + [SMALL_STATE(1544)] = 59803, + [SMALL_STATE(1545)] = 59810, + [SMALL_STATE(1546)] = 59817, + [SMALL_STATE(1547)] = 59824, + [SMALL_STATE(1548)] = 59831, + [SMALL_STATE(1549)] = 59838, + [SMALL_STATE(1550)] = 59845, + [SMALL_STATE(1551)] = 59852, + [SMALL_STATE(1552)] = 59859, + [SMALL_STATE(1553)] = 59866, + [SMALL_STATE(1554)] = 59873, + [SMALL_STATE(1555)] = 59880, + [SMALL_STATE(1556)] = 59887, + [SMALL_STATE(1557)] = 59894, + [SMALL_STATE(1558)] = 59901, + [SMALL_STATE(1559)] = 59908, + [SMALL_STATE(1560)] = 59915, + [SMALL_STATE(1561)] = 59922, + [SMALL_STATE(1562)] = 59929, + [SMALL_STATE(1563)] = 59936, + [SMALL_STATE(1564)] = 59943, + [SMALL_STATE(1565)] = 59950, + [SMALL_STATE(1566)] = 59957, + [SMALL_STATE(1567)] = 59964, + [SMALL_STATE(1568)] = 59971, + [SMALL_STATE(1569)] = 59978, + [SMALL_STATE(1570)] = 59985, + [SMALL_STATE(1571)] = 59992, + [SMALL_STATE(1572)] = 59999, + [SMALL_STATE(1573)] = 60006, + [SMALL_STATE(1574)] = 60013, + [SMALL_STATE(1575)] = 60020, + [SMALL_STATE(1576)] = 60027, + [SMALL_STATE(1577)] = 60034, + [SMALL_STATE(1578)] = 60041, + [SMALL_STATE(1579)] = 60048, + [SMALL_STATE(1580)] = 60055, + [SMALL_STATE(1581)] = 60062, + [SMALL_STATE(1582)] = 60069, + [SMALL_STATE(1583)] = 60076, + [SMALL_STATE(1584)] = 60083, + [SMALL_STATE(1585)] = 60090, + [SMALL_STATE(1586)] = 60097, + [SMALL_STATE(1587)] = 60104, + [SMALL_STATE(1588)] = 60111, + [SMALL_STATE(1589)] = 60118, + [SMALL_STATE(1590)] = 60125, + [SMALL_STATE(1591)] = 60132, + [SMALL_STATE(1592)] = 60139, + [SMALL_STATE(1593)] = 60146, + [SMALL_STATE(1594)] = 60153, + [SMALL_STATE(1595)] = 60160, + [SMALL_STATE(1596)] = 60167, + [SMALL_STATE(1597)] = 60174, + [SMALL_STATE(1598)] = 60181, + [SMALL_STATE(1599)] = 60188, + [SMALL_STATE(1600)] = 60195, + [SMALL_STATE(1601)] = 60202, + [SMALL_STATE(1602)] = 60209, + [SMALL_STATE(1603)] = 60216, + [SMALL_STATE(1604)] = 60223, + [SMALL_STATE(1605)] = 60230, + [SMALL_STATE(1606)] = 60237, + [SMALL_STATE(1607)] = 60244, + [SMALL_STATE(1608)] = 60251, + [SMALL_STATE(1609)] = 60258, + [SMALL_STATE(1610)] = 60265, + [SMALL_STATE(1611)] = 60272, + [SMALL_STATE(1612)] = 60279, + [SMALL_STATE(1613)] = 60286, + [SMALL_STATE(1614)] = 60293, + [SMALL_STATE(1615)] = 60300, + [SMALL_STATE(1616)] = 60307, + [SMALL_STATE(1617)] = 60314, + [SMALL_STATE(1618)] = 60321, + [SMALL_STATE(1619)] = 60328, + [SMALL_STATE(1620)] = 60335, + [SMALL_STATE(1621)] = 60342, + [SMALL_STATE(1622)] = 60349, + [SMALL_STATE(1623)] = 60356, + [SMALL_STATE(1624)] = 60363, + [SMALL_STATE(1625)] = 60370, + [SMALL_STATE(1626)] = 60377, + [SMALL_STATE(1627)] = 60384, + [SMALL_STATE(1628)] = 60391, + [SMALL_STATE(1629)] = 60398, + [SMALL_STATE(1630)] = 60405, + [SMALL_STATE(1631)] = 60412, + [SMALL_STATE(1632)] = 60419, + [SMALL_STATE(1633)] = 60426, + [SMALL_STATE(1634)] = 60433, + [SMALL_STATE(1635)] = 60440, + [SMALL_STATE(1636)] = 60447, + [SMALL_STATE(1637)] = 60454, + [SMALL_STATE(1638)] = 60461, + [SMALL_STATE(1639)] = 60468, + [SMALL_STATE(1640)] = 60475, + [SMALL_STATE(1641)] = 60482, + [SMALL_STATE(1642)] = 60489, + [SMALL_STATE(1643)] = 60496, + [SMALL_STATE(1644)] = 60503, + [SMALL_STATE(1645)] = 60510, + [SMALL_STATE(1646)] = 60517, + [SMALL_STATE(1647)] = 60524, + [SMALL_STATE(1648)] = 60531, + [SMALL_STATE(1649)] = 60538, + [SMALL_STATE(1650)] = 60545, + [SMALL_STATE(1651)] = 60552, + [SMALL_STATE(1652)] = 60559, + [SMALL_STATE(1653)] = 60566, + [SMALL_STATE(1654)] = 60573, + [SMALL_STATE(1655)] = 60580, + [SMALL_STATE(1656)] = 60587, + [SMALL_STATE(1657)] = 60594, + [SMALL_STATE(1658)] = 60601, + [SMALL_STATE(1659)] = 60608, + [SMALL_STATE(1660)] = 60615, + [SMALL_STATE(1661)] = 60622, + [SMALL_STATE(1662)] = 60629, + [SMALL_STATE(1663)] = 60636, + [SMALL_STATE(1664)] = 60643, + [SMALL_STATE(1665)] = 60650, + [SMALL_STATE(1666)] = 60657, + [SMALL_STATE(1667)] = 60664, + [SMALL_STATE(1668)] = 60671, + [SMALL_STATE(1669)] = 60678, + [SMALL_STATE(1670)] = 60685, + [SMALL_STATE(1671)] = 60692, + [SMALL_STATE(1672)] = 60699, + [SMALL_STATE(1673)] = 60706, + [SMALL_STATE(1674)] = 60713, + [SMALL_STATE(1675)] = 60720, + [SMALL_STATE(1676)] = 60727, + [SMALL_STATE(1677)] = 60734, + [SMALL_STATE(1678)] = 60741, + [SMALL_STATE(1679)] = 60748, + [SMALL_STATE(1680)] = 60755, + [SMALL_STATE(1681)] = 60762, + [SMALL_STATE(1682)] = 60769, + [SMALL_STATE(1683)] = 60776, + [SMALL_STATE(1684)] = 60783, + [SMALL_STATE(1685)] = 60790, + [SMALL_STATE(1686)] = 60797, + [SMALL_STATE(1687)] = 60804, + [SMALL_STATE(1688)] = 60811, + [SMALL_STATE(1689)] = 60818, + [SMALL_STATE(1690)] = 60825, + [SMALL_STATE(1691)] = 60832, + [SMALL_STATE(1692)] = 60839, + [SMALL_STATE(1693)] = 60846, + [SMALL_STATE(1694)] = 60853, + [SMALL_STATE(1695)] = 60860, + [SMALL_STATE(1696)] = 60867, + [SMALL_STATE(1697)] = 60874, + [SMALL_STATE(1698)] = 60881, + [SMALL_STATE(1699)] = 60888, + [SMALL_STATE(1700)] = 60895, + [SMALL_STATE(1701)] = 60902, + [SMALL_STATE(1702)] = 60909, + [SMALL_STATE(1703)] = 60916, + [SMALL_STATE(1704)] = 60923, + [SMALL_STATE(1705)] = 60930, + [SMALL_STATE(1706)] = 60937, + [SMALL_STATE(1707)] = 60944, + [SMALL_STATE(1708)] = 60951, + [SMALL_STATE(1709)] = 60958, + [SMALL_STATE(1710)] = 60965, + [SMALL_STATE(1711)] = 60972, + [SMALL_STATE(1712)] = 60979, + [SMALL_STATE(1713)] = 60986, + [SMALL_STATE(1714)] = 60993, + [SMALL_STATE(1715)] = 61000, + [SMALL_STATE(1716)] = 61007, + [SMALL_STATE(1717)] = 61014, + [SMALL_STATE(1718)] = 61021, + [SMALL_STATE(1719)] = 61028, + [SMALL_STATE(1720)] = 61035, + [SMALL_STATE(1721)] = 61042, + [SMALL_STATE(1722)] = 61049, + [SMALL_STATE(1723)] = 61056, + [SMALL_STATE(1724)] = 61063, + [SMALL_STATE(1725)] = 61070, + [SMALL_STATE(1726)] = 61077, + [SMALL_STATE(1727)] = 61084, + [SMALL_STATE(1728)] = 61091, + [SMALL_STATE(1729)] = 61098, + [SMALL_STATE(1730)] = 61105, + [SMALL_STATE(1731)] = 61112, + [SMALL_STATE(1732)] = 61119, + [SMALL_STATE(1733)] = 61126, + [SMALL_STATE(1734)] = 61133, + [SMALL_STATE(1735)] = 61140, + [SMALL_STATE(1736)] = 61147, + [SMALL_STATE(1737)] = 61154, + [SMALL_STATE(1738)] = 61161, + [SMALL_STATE(1739)] = 61168, + [SMALL_STATE(1740)] = 61175, + [SMALL_STATE(1741)] = 61182, + [SMALL_STATE(1742)] = 61189, + [SMALL_STATE(1743)] = 61196, + [SMALL_STATE(1744)] = 61203, + [SMALL_STATE(1745)] = 61210, + [SMALL_STATE(1746)] = 61217, + [SMALL_STATE(1747)] = 61224, + [SMALL_STATE(1748)] = 61231, + [SMALL_STATE(1749)] = 61238, + [SMALL_STATE(1750)] = 61245, + [SMALL_STATE(1751)] = 61252, + [SMALL_STATE(1752)] = 61259, + [SMALL_STATE(1753)] = 61266, + [SMALL_STATE(1754)] = 61273, + [SMALL_STATE(1755)] = 61280, + [SMALL_STATE(1756)] = 61287, + [SMALL_STATE(1757)] = 61294, + [SMALL_STATE(1758)] = 61301, + [SMALL_STATE(1759)] = 61308, + [SMALL_STATE(1760)] = 61315, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -57373,206 +57643,206 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(410), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1016), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1225), - [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1729), - [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1285), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1602), - [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1706), - [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1479), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1555), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(408), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1062), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1268), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1384), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1367), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1404), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1447), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1758), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1573), [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1179), - [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1243), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1656), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1227), + [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1204), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1381), [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), - [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1530), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1549), - [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1313), - [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1557), - [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1587), - [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1290), - [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1626), - [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(475), - [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), - [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(477), - [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1452), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1481), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1343), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1655), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1657), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1350), + [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1679), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(526), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(510), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(510), + [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(399), - [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), - [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), - [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(292), + [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(520), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(294), [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), - [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), [87] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), - [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1675), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1685), [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1018), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1051), [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(218), - [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), - [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1248), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1227), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1704), + [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1247), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1215), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193), [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(194), [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(5), - [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1744), - [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1705), - [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1354), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1632), - [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(357), - [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), - [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), - [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), - [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1512), - [137] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(410), - [140] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1016), - [143] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(2), - [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), - [148] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1225), - [151] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1729), - [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1285), - [157] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(135), - [160] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1602), - [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1706), - [166] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1026), - [169] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1479), - [172] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1555), - [175] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(159), - [178] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(34), - [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(187), - [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(190), - [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1179), - [190] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1243), - [193] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1656), - [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(197), - [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(59), - [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), - [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1530), - [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), - [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1313), - [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1557), - [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1587), - [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1290), - [223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1626), - [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(475), - [229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(477), - [232] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(477), - [235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), - [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1754), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1715), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1366), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1642), + [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(393), + [131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [133] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(408), + [136] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1062), + [139] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(4), + [142] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1268), + [145] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1384), + [148] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1367), + [151] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(142), + [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1404), + [157] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1447), + [160] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1018), + [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1758), + [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1573), + [169] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(159), + [172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(43), + [175] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(187), + [178] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(190), + [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1227), + [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1204), + [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1381), + [190] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(197), + [193] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(59), + [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), + [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1452), + [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1481), + [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), + [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1655), + [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1657), + [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1350), + [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1679), + [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(526), + [223] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(510), + [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(510), + [229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), + [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), - [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1521), - [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), - [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), - [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1672), - [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(230), - [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1633), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(705), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1670), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(228), + [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1437), [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1033), + [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1035), [262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), - [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), + [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), [268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), - [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1245), - [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1194), - [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1670), + [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1241), + [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1165), + [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1680), [276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(182), [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), - [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1738), - [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1671), - [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1349), - [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1546), - [292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1748), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1681), + [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1270), + [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1556), + [292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), [294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), [296] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), [298] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), - [300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(403), - [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1548), - [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1026), + [300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), + [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1558), + [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1018), [306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), - [308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), - [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1187), - [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1419), - [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1271), - [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1453), - [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1455), - [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1456), - [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1457), - [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1466), - [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1325), - [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1471), - [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(409), - [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), - [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), - [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(509), - [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), - [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), - [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), - [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), - [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), - [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), - [356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), - [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), - [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), - [364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(414), - [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), + [308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1184), + [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1542), + [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1322), + [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1504), + [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1561), + [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1682), + [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1418), + [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1459), + [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1283), + [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1553), + [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(405), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), + [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), + [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), + [358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), + [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), + [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(380), [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), - [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), - [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), - [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), - [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), - [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(407), + [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), + [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), [386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), [388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_doc_comment, 1, 0, 0), - [392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), - [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), - [396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [400] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(227), - [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2, 0, 0), - [405] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2, 0, 0), - [407] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), - [409] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), - [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), - [413] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1197), - [416] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(834), - [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), - [421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), - [423] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), - [425] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), - [427] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1719), - [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 42), - [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), - [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), - [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 42), + [390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [394] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(226), + [397] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_doc_comment, 1, 0, 0), + [399] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), + [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [403] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), + [405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1174), + [412] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(835), + [415] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2, 0, 0), + [417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2, 0, 0), + [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [423] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1659), + [426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), + [428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), + [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 66), + [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1664), + [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1364), + [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 66), [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), [440] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), - [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), [448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), @@ -57580,1390 +57850,1401 @@ static const TSParseActionEntry ts_parse_actions[] = { [452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), [454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), - [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), - [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 49), - [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 49), - [466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 12), - [468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), - [470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 54), - [472] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1351), - [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), - [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 60), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 60), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 62), - [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 62), - [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 13), - [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 13), - [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), - [495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), - [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [499] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1351), - [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 79), - [506] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1351), - [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), - [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_expression, 4, 0, 21), - [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_kernel_expression, 4, 0, 21), - [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), - [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), - [519] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1200), - [522] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 104), - [524] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1351), - [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), - [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 36), - [531] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1351), - [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), - [536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 7, 0, 95), - [538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 7, 0, 95), - [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), - [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), - [544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 122), - [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 122), - [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), - [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), - [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), - [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), - [556] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [559] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), - [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), - [566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), - [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), - [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), - [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), - [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), - [576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), - [578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), - [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), - [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), - [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), - [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), - [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), - [590] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 11), - [592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 11), - [594] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), - [596] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), - [598] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), - [600] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), - [602] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), - [604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), - [606] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), - [608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), - [610] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), - [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), - [614] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [617] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), - [622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), - [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), - [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), - [628] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), - [631] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), - [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), - [636] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), - [638] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), - [640] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), - [642] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 33), - [644] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 33), - [646] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), - [648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), - [650] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), - [652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), - [654] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), - [656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 4), - [658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 30), - [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 30), - [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 33), - [664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 33), - [666] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 66), - [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 66), - [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 94), - [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 94), - [674] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 66), - [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 66), - [678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 96), - [680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 96), - [682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 8, 0, 96), - [684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 8, 0, 96), - [686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 138), - [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 138), - [690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), - [692] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1233), - [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), - [697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), - [699] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), - [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), - [703] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1540), - [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), - [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), - [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [722] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), - [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), - [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), - [732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 99), - [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 106), - [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 109), - [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 18), - [740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 124), - [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 125), - [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 130), - [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 133), - [748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 134), - [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 81), - [752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 144), - [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 147), - [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 151), - [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 152), - [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 154), + [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(767), + [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), + [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 127), + [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 127), + [466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1177), + [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), + [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), + [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), + [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 12), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), + [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 13), + [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 13), + [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [491] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1364), + [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_expression, 4, 0, 21), + [498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_kernel_expression, 4, 0, 21), + [500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 38), + [506] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1364), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 44), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 44), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 51), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 51), + [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 58), + [521] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1364), + [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), + [526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 64), + [528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 64), + [530] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 84), + [532] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1364), + [535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), + [537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 7, 0, 100), + [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 7, 0, 100), + [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 109), + [543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1364), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), + [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), + [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), + [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), + [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), + [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), + [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), + [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), + [562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), + [564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), + [566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), + [568] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), + [570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), + [572] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), + [574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), + [576] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), + [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), + [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), + [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), + [590] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), + [593] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 29), + [596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), + [598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), + [600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), + [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), + [604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), + [606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), + [608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 35), + [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 35), + [612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), + [614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), + [616] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), + [618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), + [620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), + [622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), + [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 11), + [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 11), + [628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), + [630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 4), + [632] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 30), + [634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 30), + [636] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), + [638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), + [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 35), + [642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 35), + [644] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [648] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [651] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [654] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), + [656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), + [658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 70), + [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 70), + [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), + [664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), + [666] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 99), + [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 99), + [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), + [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), + [674] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 70), + [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 70), + [678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 101), + [680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 101), + [682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), + [684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), + [686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 8, 0, 101), + [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 8, 0, 101), + [690] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), + [692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), + [694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 143), + [696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 143), + [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), + [700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1223), + [703] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1550), + [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), + [710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 178), + [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [714] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), + [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [726] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), + [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), + [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 86), + [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 111), + [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 114), + [740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 87), + [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 54), + [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 129), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 130), + [748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 135), + [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 138), + [752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 139), + [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 57), + [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 149), + [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 152), + [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 156), [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 157), - [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 160), - [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 161), - [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 163), - [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 166), - [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 172), - [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 173), - [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 175), - [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 176), - [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 177), + [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), + [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 162), + [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 165), + [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 166), + [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 168), + [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), + [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 177), + [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 18), + [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 180), [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 181), - [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 184), - [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 98), - [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 188), - [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 189), - [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 192), - [794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1235), - [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 82), - [799] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1356), - [802] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1356), - [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 50), - [807] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1356), - [810] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1356), - [813] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1356), - [816] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 53), - [818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 55), - [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 185), - [822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 45), - [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), SHIFT(1351), - [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), - [829] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 45), - [831] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), SHIFT(1351), - [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), - [836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1539), - [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), - [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), - [843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1189), + [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), + [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 186), + [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 189), + [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 190), + [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 193), + [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 194), + [796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 197), + [798] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1225), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 59), + [803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 104), + [805] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1368), + [808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1368), + [811] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1368), + [814] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1368), + [817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1368), + [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 103), + [822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 47), + [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 47), SHIFT(1364), + [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 47), + [829] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 47), + [831] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 47), SHIFT(1364), + [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 47), + [836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), + [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), + [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), + [843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1269), [846] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(188), [849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), - [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), - [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1542), - [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1682), - [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1714), - [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), - [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), - [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1667), - [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), - [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), - [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), - [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), - [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), - [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), - [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), - [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1418), - [881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), - [883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1494), - [885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), - [887] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), - [889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), - [891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), - [893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), - [895] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1542), - [898] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1682), - [901] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1714), - [904] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1666), - [907] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1715), - [910] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1667), - [913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1716), - [916] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1320), - [919] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(547), - [922] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1673), - [925] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), - [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), - [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), - [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1484), - [937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), - [939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1372), - [941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), - [943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), - [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(757), - [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(717), - [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), - [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), - [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), - [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(692), - [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), - [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(698), - [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), - [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), - [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(705), - [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), - [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(710), - [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(711), - [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), - [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), - [977] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1497), - [980] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), - [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), - [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), - [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), - [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), - [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [996] = {.entry = {.count = 1, .reusable = false}}, SHIFT(128), - [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [1008] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), - [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1568), - [1016] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), - [1018] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 54), SHIFT(1263), - [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1023] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [1025] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 104), SHIFT(1263), - [1028] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), - [1030] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1263), - [1033] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 79), SHIFT(1263), - [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), - [1038] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1260), - [1041] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1263), - [1044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), - [1046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), - [1048] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), - [1050] = {.entry = {.count = 1, .reusable = false}}, SHIFT(827), - [1052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), - [1054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(510), - [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), - [1058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1112), - [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), - [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), - [1064] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), - [1066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), - [1068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 17), - [1070] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 61), - [1072] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 63), - [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), - [1076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), - [1078] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 41), - [1080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), - [1082] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 43), - [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), - [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1558), - [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), - [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), - [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(754), - [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(492), - [1096] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), - [1099] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1270), - [1102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [1104] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1294), - [1107] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), - [1110] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(629), - [1113] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1267), - [1116] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1119] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), - [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), - [1124] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), - [1127] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1270), - [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), - [1132] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1294), - [1135] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), - [1138] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(629), - [1141] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1267), - [1144] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1091), - [1147] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1112), - [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1660), - [1152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), - [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), - [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [1168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), - [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), - [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), - [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), - [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(508), - [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), - [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), - [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), - [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), - [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), - [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), - [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), - [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), - [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), - [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), - [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), - [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), - [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), - [1216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [1218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), - [1220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), - [1222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), - [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1606), - [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), + [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), + [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), + [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1724), + [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), + [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1725), + [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), + [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), + [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), + [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), + [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), + [883] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), + [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1580), + [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1733), + [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [892] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), + [894] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), + [897] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1471), + [900] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1724), + [903] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1676), + [906] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1725), + [909] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1677), + [912] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1726), + [915] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1352), + [918] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(594), + [921] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1683), + [924] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1750), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), + [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), + [937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(725), + [939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), + [941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1427), + [943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), + [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), + [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(708), + [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), + [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), + [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), + [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), + [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [977] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), + [979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), + [981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), + [983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), + [985] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), + [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), + [998] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1342), + [1001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [1003] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), + [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [1009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [1011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [1015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [1019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), + [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [1023] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), + [1025] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1149), + [1028] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1342), + [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 65), + [1033] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 43), + [1035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), + [1037] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1342), + [1040] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1342), + [1043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), + [1045] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1342), + [1048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), + [1052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), + [1054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), + [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [1058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(831), + [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), + [1066] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1076), + [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), + [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), + [1072] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1117), + [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), + [1076] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 45), + [1078] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 17), + [1080] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 67), + [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [1084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), + [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(754), + [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), + [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), + [1094] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), + [1097] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1271), + [1100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [1102] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1276), + [1105] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), + [1108] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(628), + [1111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1279), + [1114] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1117), + [1117] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), + [1120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), + [1122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), + [1124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [1126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [1128] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), + [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [1132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), + [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), + [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1589), + [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), + [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), + [1196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), + [1198] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), + [1201] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1271), + [1204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), + [1206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1276), + [1209] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), + [1212] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(628), + [1215] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1279), + [1218] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1117), + [1221] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), + [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), - [1234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), - [1236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), - [1238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), - [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), - [1244] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), - [1246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), - [1248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(520), - [1250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), - [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), - [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), - [1258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), - [1260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), - [1262] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), - [1264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), - [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), - [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), - [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), - [1276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1483), - [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), - [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(759), - [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), - [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), - [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), - [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), - [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), - [1292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), - [1294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1734), - [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), - [1300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1743), - [1303] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1715), - [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1667), - [1309] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1326), - [1312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), - [1315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [1318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), - [1320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1731), - [1322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), - [1324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1415), - [1326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), - [1328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), - [1330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), - [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), - [1334] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1127), - [1337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), - [1339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), - [1341] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), - [1343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 85), - [1345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 128), - [1347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1393), - [1349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 51), - [1351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 86), - [1353] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1534), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), - [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), + [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1671), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), + [1236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), + [1238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), + [1240] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), + [1242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), + [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), + [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), + [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), + [1252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), + [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), + [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(508), + [1258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), + [1260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), + [1262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), + [1264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), + [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(833), + [1268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), + [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1586), + [1276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), + [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), + [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), + [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1493), + [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1499), + [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1318), + [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), + [1292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(691), + [1294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), + [1296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(696), + [1298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(704), + [1300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), + [1302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), + [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1489), + [1309] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1493), + [1312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1499), + [1315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1725), + [1318] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1677), + [1321] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1318), + [1324] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1508), + [1327] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [1330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), + [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), + [1334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), + [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), + [1338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), + [1340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1126), + [1343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), + [1345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), + [1347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), + [1349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [1351] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1544), + [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 55), + [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), + [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 90), [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 19), - [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), - [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), - [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 75), - [1368] = {.entry = {.count = 1, .reusable = false}}, SHIFT(845), - [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), - [1372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1687), - [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), - [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), - [1378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), - [1380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), - [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), - [1384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1710), - [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), - [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 39), - [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), - [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 40), - [1394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 22), - [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 39), - [1398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 58), - [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), - [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), - [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 40), - [1406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 74), - [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 39), - [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 93), - [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 102), - [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(893), - [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 75), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 111), - [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 93), - [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 129), - [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 111), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 149), - [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 129), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 149), - [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 38), - [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), - [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 46), - [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 67), - [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 48), - [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 73), - [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 47), - [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 51), - [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 76), - [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 52), - [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 77), - [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 34), - [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 80), - [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 83), - [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 84), - [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 67), - [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 100), - [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 101), - [1470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), - [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 76), - [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 103), - [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 77), - [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 105), - [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 107), - [1482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 108), - [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 110), - [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 86), - [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 46), - [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), - [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 123), - [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 126), - [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 127), - [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 48), - [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 103), - [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 131), - [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 132), - [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 135), - [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), - [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 143), - [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 145), - [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 146), - [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 148), - [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 128), - [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 52), - [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 34), - [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 150), - [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 153), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), - [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), - [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 162), - [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), - [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 164), - [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 165), - [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), - [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 174), - [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 178), - [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), - [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), - [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 68), - [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 69), - [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 190), - [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 97), - [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), - [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), - [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), - [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 56), - [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 57), - [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), - [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), - [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), - [1574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1469), - [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), - [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(971), - [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), - [1582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1490), - [1585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1580), - [1587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), - [1589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1401), - [1591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), - [1593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), - [1595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), - [1597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1614), - [1599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), - [1601] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1469), - [1604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), - [1606] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(971), - [1609] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(949), - [1612] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [1615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), - [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), - [1619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), - [1621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1650), - [1623] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1541), - [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1593), - [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), - [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), - [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), - [1634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), - [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), - [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), - [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), - [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), - [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), - [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1740), - [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 133), + [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 91), + [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 22), + [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), + [1370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), + [1372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(623), + [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), + [1376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1720), + [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), + [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 41), + [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 42), + [1386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 41), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 62), + [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), + [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [1394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(922), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [1398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1697), + [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(818), + [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 42), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 79), + [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), + [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 80), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 41), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 98), + [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 107), + [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), + [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 80), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 116), + [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 98), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 134), + [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 116), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 154), + [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 134), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 154), + [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 187), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 55), + [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 40), + [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 81), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 56), + [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 82), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 36), + [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 85), + [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 88), + [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 89), + [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 56), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 71), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 105), + [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 106), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 36), + [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), + [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), + [1470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), + [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), + [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 81), + [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 108), + [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 82), + [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 110), + [1482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 72), + [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 112), + [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 113), + [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 73), + [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 115), + [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 91), + [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 60), + [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 61), + [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 128), + [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 131), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 132), + [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 108), + [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 136), + [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 50), + [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 140), + [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), + [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 148), + [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 150), + [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 151), + [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 153), + [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 133), + [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), + [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 155), + [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 163), + [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 164), + [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 167), + [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 48), + [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 169), + [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 170), + [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 176), + [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 179), + [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), + [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), + [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 188), + [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 195), + [1558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 102), + [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 48), + [1562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), + [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 71), + [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 50), + [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 78), + [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 49), + [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 137), + [1574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1562), + [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), + [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(983), + [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(961), + [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), + [1586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), + [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), + [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), + [1592] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1500), + [1595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1559), + [1597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1507), + [1599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), + [1601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1380), + [1603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), + [1605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(931), + [1607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), + [1609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 125), + [1611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), + [1613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), + [1615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), + [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [1619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), + [1621] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1551), + [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1449), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1638), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), + [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), + [1636] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 98), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), - [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 168), - [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 173), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(680), - [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), - [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), - [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), - [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), - [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), - [1676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 93), - [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), - [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), - [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 120), - [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), - [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 156), - [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), - [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), - [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), - [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 72), - [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), - [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), - [1700] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 187), - [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 140), - [1704] = {.entry = {.count = 1, .reusable = false}}, SHIFT(657), - [1706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1385), - [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), - [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), - [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), - [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1379), - [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), - [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1514), - [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1566), - [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), - [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), - [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), - [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), - [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1681), - [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1722), - [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), - [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(604), - [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), - [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), - [1742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 179), - [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1490), - [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), - [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), - [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), - [1752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(836), - [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), - [1756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), - [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), - [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), - [1762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 142), - [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), - [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), - [1768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 93), - [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), - [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 70), - [1774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 191), - [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), - [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), - [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), - [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), - [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), - [1786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(980), - [1788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(439), - [1790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 92), - [1792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), - [1794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1537), - [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 119), - [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), - [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 121), - [1803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 180), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1613), + [1672] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1562), + [1675] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), + [1677] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(983), + [1680] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(961), + [1683] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), + [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), + [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), + [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 192), + [1696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 161), + [1698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 76), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), + [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), + [1704] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 145), + [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1536), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1576), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1400), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1730), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1577), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1731), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), + [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), + [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), + [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(559), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), + [1728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), + [1734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 184), + [1736] = {.entry = {.count = 1, .reusable = false}}, SHIFT(871), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1389), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1524), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), + [1748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 147), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), + [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), + [1760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(834), + [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [1764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), + [1768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 98), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), + [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), + [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), + [1776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 185), + [1778] = {.entry = {.count = 1, .reusable = false}}, SHIFT(984), + [1780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(437), + [1782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), + [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 124), + [1786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 126), + [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), + [1790] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1547), + [1793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 146), + [1795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 74), + [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), + [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 160), + [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 91), + [1803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), [1805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), - [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 186), - [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), - [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 141), - [1813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 155), - [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 86), - [1817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 71), - [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), - [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), - [1823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 167), - [1825] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 169), - [1827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 170), - [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), - [1831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 87), - [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 87), - [1835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 136), - [1837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 136), - [1839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 137), - [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 137), - [1843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 112), - [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 112), - [1851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 113), - [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 113), - [1855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 114), - [1857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 114), - [1859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 115), - [1861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 115), - [1863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), - [1865] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 116), - [1867] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 116), - [1869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1631), - [1871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), - [1873] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1630), - [1875] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 117), - [1877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 117), - [1879] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1638), - [1881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(956), - [1883] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 89), - [1885] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 89), - [1887] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1613), - [1889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), - [1891] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1609), - [1893] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 90), - [1895] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 90), - [1897] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1621), - [1899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), - [1901] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1620), + [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 172), + [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), + [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 174), + [1813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 175), + [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 191), + [1817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 75), + [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 196), + [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 97), + [1823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), + [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1148), + [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), + [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), + [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [1833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), + [1835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 97), + [1837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 97), + [1839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 121), + [1845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 121), + [1847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 142), + [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 142), + [1851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 141), + [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 141), + [1855] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1634), + [1857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), + [1859] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1632), + [1861] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1643), + [1863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), + [1865] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1640), + [1867] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1648), + [1869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(957), + [1871] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 63), + [1873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 63), + [1875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [1877] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1698), + [1883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), + [1885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1695), + [1887] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 93), + [1889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 93), + [1891] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 94), + [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 94), + [1895] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 122), + [1897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 122), + [1899] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1502), + [1901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), [1903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1473), - [1905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), - [1907] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1472), - [1909] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1627), - [1911] = {.entry = {.count = 1, .reusable = false}}, SHIFT(960), - [1913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 91), - [1915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 91), - [1917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 88), - [1919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 88), - [1921] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 59), - [1923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 59), - [1925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 92), - [1927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 92), - [1929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [1931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), - [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), - [1937] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1939] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1941] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1645), - [1943] = {.entry = {.count = 1, .reusable = false}}, SHIFT(958), - [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [1947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), - [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [1953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), - [1955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [1957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), - [1959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), - [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), - [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), - [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(914), - [1975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), - [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [1981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), - [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), - [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), - [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [1905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 117), + [1907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 117), + [1909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 118), + [1911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 118), + [1913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 95), + [1915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 95), + [1917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 96), + [1919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 96), + [1921] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1512), + [1923] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), + [1925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 119), + [1927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 119), + [1929] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 120), + [1931] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 120), + [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [1937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), + [1939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1102), + [1941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [1943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), + [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [1947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), + [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [1953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [1955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [1957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), + [1959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), + [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), + [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), + [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), + [1975] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), + [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), + [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), - [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), - [2003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [2005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), - [2007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), - [2009] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1078), - [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), - [2013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1310), - [2015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1576), - [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), - [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [2021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), - [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), - [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), - [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), - [2035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), - [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), - [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1237), - [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), - [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), - [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), - [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), - [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), - [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), - [2069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), - [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), - [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), - [2077] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), - [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), - [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), - [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), - [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [2089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [2091] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(902), - [2094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), - [2096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), - [2098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), - [2100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), - [2102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), - [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [2106] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1257), - [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [2111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(196), - [2114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1615), - [2116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), - [2118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1059), - [2120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), - [2122] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), - [2124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), - [2126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), - [2128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), - [2130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), - [2132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [2134] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1528), - [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), - [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 118), - [2141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), - [2143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [2145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), - [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), - [2149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1506), - [2151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), - [2153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), - [2155] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1528), - [2158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), - [2160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), - [2162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), - [2164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), - [2166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), - [2168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), - [2170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), - [2172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 64), - [2174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 64), - [2176] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1192), - [2179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), - [2181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1059), - [2184] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), - [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), - [2188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), - [2190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), - [2192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1615), - [2195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), - [2197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 44), - [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(765), - [2201] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1528), - [2204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), - [2206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), - [2208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), - [2210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), - [2212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 139), - [2214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), - [2216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), - [2218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), - [2220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), - [2222] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), - [2224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), - [2226] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), - [2228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), - [2230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), - [2232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), - [2234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), - [2236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), - [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), - [2240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), - [2242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), - [2244] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), - [2246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), - [2248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), - [2250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1357), - [2252] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), - [2254] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1452), - [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [2261] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1121), - [2264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), - [2266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), - [2268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1492), - [2270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), - [2272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), - [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [2276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [2278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), - [2280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [2282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), - [2284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), - [2286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [2288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), - [2290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [2292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), - [2294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), - [2296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1595), - [2298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [2300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 65), SHIFT_REPEAT(1281), - [2303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 65), - [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [2309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), - [2311] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1291), - [2314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [2316] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 65), SHIFT_REPEAT(631), - [2319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 65), - [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), - [2323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), - [2325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), - [2327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), - [2329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), - [2331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), - [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [2335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [2337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [2339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1116), - [2341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [2343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), - [2345] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(38), - [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), - [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), - [2354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), - [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1347), - [2358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [2360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [2362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [2364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [2366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), - [2368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), - [2370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), - [2372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [2374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [2376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), - [2378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), - [2380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [2382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), - [2384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [2386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), - [2390] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1452), - [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [2401] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1140), - [2404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), - [2406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), - [2408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), - [2410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), - [2412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), - [2414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), - [2416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), - [2418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), - [2420] = {.entry = {.count = 1, .reusable = false}}, SHIFT(965), - [2422] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1265), - [2424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), - [2426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), - [2428] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1338), - [2431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), - [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), - [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [2437] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), - [2439] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1452), - [2442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), - [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), - [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1369), - [2450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [2452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [2454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [2458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), - [2460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1055), - [2462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), - [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), - [2466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1055), - [2469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), - [2471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), - [2473] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1347), - [2476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1583), - [2478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), - [2480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [2482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), - [2484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), - [2486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), - [2488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), - [2490] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1357), - [2493] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), - [2495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), - [2497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [2499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [2501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), - [2503] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1304), - [2506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), - [2508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), - [2510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), - [2512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1637), - [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [2516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), - [2518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [2520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [2522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), - [2524] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1489), - [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), - [2529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), - [2531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), - [2533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(947), - [2535] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1322), - [2537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [2539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(959), - [2541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1333), - [2543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(630), - [2546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), - [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), - [2552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), - [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), - [2556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), - [2560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), - [2562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1247), - [2564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), - [2566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), - [2568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [2570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), - [2572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1095), - [2574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [2576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), - [2578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), - [2580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1283), - [2582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1000), - [2584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), - [2586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(783), - [2588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), - [2590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 44), - [2592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), - [2594] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1289), - [2596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), - [2598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), - [2600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), - [2602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), - [2604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [2606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), - [2608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), - [2610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 44), - [2612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), - [2614] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1335), - [2616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), - [2618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), - [2620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), - [2622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(800), - [2624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1001), - [2626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), - [2628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [2630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), - [2632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [2634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), - [2636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), - [2638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), - [2640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(798), - [2642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), - [2644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), - [2646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [2648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), - [2650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [2652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), - [2654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), - [2656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), - [2658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), - [2660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(781), - [2662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), - [2664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 78), - [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1417), - [2668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), - [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), - [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), - [2676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(951), - [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), - [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), - [2682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), - [2684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), - [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), - [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), - [2690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), - [2692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), - [2694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1013), - [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), - [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), - [2700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), - [2702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), - [2704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), - [2706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [2708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(778), - [2710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), - [2712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 37), - [2714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), - [2716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [2718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), - [2720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), - [2722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), - [2724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [2726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), - [2728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [2730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), - [2732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), - [2734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1695), - [2736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), - [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [2740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), - [2742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), - [2744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(789), - [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [2752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), - [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), - [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), - [2760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), - [2762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), - [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), - [2766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), - [2768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), - [2772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), - [2774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [2776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), - [2778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), - [2780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), - [2782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(690), - [2784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), - [2786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), - [2788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), - [2790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), - [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), - [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), - [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(847), - [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), - [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), - [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1711), - [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), - [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), - [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), - [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), - [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [2822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), - [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(984), - [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), - [2830] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(806), - [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), - [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), - [2838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1296), - [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), - [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), - [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), - [2846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), - [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), - [2850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), - [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), - [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(809), - [2856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), - [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), - [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), - [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), - [2866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), - [2868] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_arguments, 3, 0, 0), - [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), - [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), - [2874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 34), - [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [2878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 35), - [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1373), - [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), - [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(983), - [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), - [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), - [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1394), - [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), - [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), - [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), - [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), - [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), - [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), - [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), - [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), - [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), - [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), - [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), - [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), - [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(638), - [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), - [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), - [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), - [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), - [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(515), - [2930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), - [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), - [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), - [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), - [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), - [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), - [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(838), - [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), - [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), - [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [2950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), - [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), - [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), - [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1591), - [2960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), - [2962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), - [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), - [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), - [2968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), - [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), - [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), - [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), - [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), - [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [2984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), - [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(382), - [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), - [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), - [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), - [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1474), - [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), - [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), - [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), - [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), - [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), - [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), - [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), - [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), - [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), - [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), - [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), - [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), - [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), - [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), - [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1319), - [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), - [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1341), - [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), - [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), - [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), - [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1220), - [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), - [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), - [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), - [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(641), - [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), - [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), - [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), - [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1395), - [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), - [3076] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), - [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(427), - [3082] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), - [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(762), - [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), - [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), - [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), - [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), - [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), - [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), - [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), - [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), - [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), - [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), - [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), - [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), - [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), - [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), - [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), - [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), - [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), - [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(792), - [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), - [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), - [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), - [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1594), - [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(794), - [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), - [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), - [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), - [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), - [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), - [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), - [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1496), - [3156] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), - [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), - [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), - [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), - [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1286), - [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1115), - [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), - [3174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), - [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1481), - [3178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), - [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(613), - [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [3186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1371), - [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), - [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), - [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), - [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), - [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), - [3200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), - [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), - [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [3206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), - [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1559), - [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), - [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), - [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1571), - [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), - [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), - [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), - [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1314), - [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), - [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), - [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1589), - [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), - [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1597), - [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), - [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), - [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), - [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), - [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1607), - [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), - [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), - [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), - [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), - [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), - [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), - [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), - [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), - [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), - [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), - [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), - [3276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), - [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), - [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), - [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), - [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), - [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), - [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1690), - [3292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), - [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), - [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), - [3298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), - [3300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), - [3302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1697), - [3304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [3306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), - [3308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), - [3310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1712), - [3312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), - [3314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), - [3318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), - [3320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), - [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [3324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), - [3326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), + [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), + [2003] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1545), + [2005] = {.entry = {.count = 1, .reusable = false}}, SHIFT(950), + [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [2011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1362), + [2013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1739), + [2015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1094), + [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), + [2019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1090), + [2021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [2027] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), + [2029] = {.entry = {.count = 1, .reusable = false}}, SHIFT(121), + [2031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), + [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [2035] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), + [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), + [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [2067] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), + [2071] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [2073] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [2075] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [2077] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), + [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1630), + [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), + [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1645), + [2085] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), + [2087] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2089] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [2091] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [2093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [2095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [2097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), + [2099] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1090), + [2102] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), + [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [2106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [2108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1496), + [2110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), + [2112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [2114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [2116] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), + [2120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), + [2122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1180), + [2124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), + [2126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), + [2128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1153), + [2130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), + [2132] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1570), + [2135] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), + [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), + [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), + [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), + [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 123), + [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 144), + [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), + [2149] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1741), + [2152] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), + [2154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [2156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1675), + [2158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), + [2160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 68), + [2162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(706), + [2164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), + [2166] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), + [2168] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(196), + [2171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1570), + [2173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), + [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1175), + [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [2179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [2181] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), + [2183] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1162), + [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [2188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1162), + [2190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [2192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), + [2194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), + [2196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [2198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), + [2200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), + [2202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1741), + [2205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), + [2207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [2209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), + [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), + [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), + [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [2217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 46), + [2219] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), + [2221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), + [2223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), + [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), + [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), + [2231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(782), + [2235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(856), + [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), + [2240] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1741), + [2243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [2245] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1153), + [2248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [2250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 68), + [2252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [2254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), + [2256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), + [2258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [2260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [2262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), + [2264] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1580), + [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), + [2269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), + [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), + [2273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), + [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), + [2277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [2279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), + [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [2283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), + [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2287] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 69), SHIFT_REPEAT(633), + [2290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 69), + [2292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), + [2294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [2296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), + [2298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [2300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [2302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), + [2304] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1338), + [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), + [2313] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), + [2315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), + [2317] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1300), + [2320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [2322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [2324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), + [2326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), + [2328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), + [2330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 34), + [2332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), + [2334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [2336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(945), + [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), + [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), + [2342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [2346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), + [2348] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(35), + [2351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [2353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [2355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1289), + [2357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), + [2359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 3, 0, 52), + [2361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), + [2363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), + [2365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [2367] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), + [2369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), + [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [2373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), + [2375] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1321), + [2378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [2380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), + [2382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [2384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), + [2386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), + [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [2390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [2392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [2396] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 53), SHIFT_REPEAT(816), + [2399] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 53), + [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), + [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [2407] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), + [2409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1580), + [2412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), + [2414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [2416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [2418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), + [2420] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1311), + [2423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), + [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), + [2431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), + [2433] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 69), SHIFT_REPEAT(1291), + [2436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 69), + [2438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [2440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), + [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), + [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [2450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), + [2452] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1213), + [2455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), + [2457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), + [2459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), + [2461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(503), + [2465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [2467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 1, 0, 0), + [2469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [2473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), + [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [2477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(969), + [2479] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1357), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [2483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [2485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), + [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), + [2489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [2493] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1335), + [2496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), + [2498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [2500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), + [2502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), + [2504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [2506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), + [2508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(953), + [2510] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1354), + [2512] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(634), + [2515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), + [2517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), + [2519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), + [2521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [2523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [2525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(965), + [2527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1360), + [2529] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1645), + [2532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [2536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), + [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), + [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 33), + [2552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [2556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), + [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2560] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1135), + [2563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), + [2565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [2569] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1097), + [2572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), + [2574] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1580), + [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), + [2581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), + [2583] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 3, 0, 77), + [2585] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1299), + [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), + [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), + [2593] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1073), + [2595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 83), + [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), + [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), + [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), + [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1109), + [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1609), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), + [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [2613] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1349), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), + [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), + [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), + [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(994), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1055), + [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1371), + [2651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 0), + [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), + [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), + [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), + [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), + [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), + [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), + [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1000), + [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), + [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), + [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), + [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), + [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), + [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [2701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), + [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(783), + [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), + [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), + [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), + [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1005), + [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(773), + [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1070), + [2727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 46), + [2729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 46), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), + [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), + [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), + [2737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), + [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [2741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), + [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), + [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [2749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), + [2751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 39), + [2753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), + [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), + [2757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), + [2765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [2769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), + [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), + [2775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(521), + [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), + [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1477), + [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), + [2785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), + [2787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [2789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [2793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [2795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [2797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [2799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [2801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), + [2803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), + [2805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), + [2807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [2809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [2811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [2813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [2815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), + [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), + [2819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), + [2821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [2823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [2825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), + [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [2829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [2831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1332), + [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), + [2835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [2837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), + [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), + [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), + [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), + [2847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [2849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), + [2851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(859), + [2853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), + [2855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [2857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [2861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [2863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), + [2865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(809), + [2867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), + [2869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), + [2871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1598), + [2873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [2875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), + [2877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [2879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [2881] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [2883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1333), + [2885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [2887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1614), + [2889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1385), + [2891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), + [2893] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), + [2895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [2897] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [2901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), + [2903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [2905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [2907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), + [2909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [2911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [2913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), + [2915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), + [2917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [2919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), + [2921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), + [2923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), + [2925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), + [2927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [2929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), + [2931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), + [2933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [2935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), + [2937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), + [2939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [2941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [2943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(806), + [2945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), + [2947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), + [2949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1546), + [2951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [2953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), + [2955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), + [2957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), + [2959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), + [2961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), + [2963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [2965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), + [2967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), + [2969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [2971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), + [2973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), + [2975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), + [2977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [2979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [2981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [2983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [2985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), + [2987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), + [2989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(621), + [2991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [2993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [2995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [2997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), + [2999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), + [3001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), + [3003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), + [3005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [3007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), + [3009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1653), + [3011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(940), + [3013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), + [3015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [3017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [3019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), + [3021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), + [3023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), + [3025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), + [3027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), + [3029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [3031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), + [3033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), + [3035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [3037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(772), + [3039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1612), + [3041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [3043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(640), + [3045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1118), + [3047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [3049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [3051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [3053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [3055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), + [3057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), + [3059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1295), + [3061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1312), + [3063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [3065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), + [3067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [3069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [3071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), + [3073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [3075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), + [3077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), + [3079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), + [3081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1170), + [3083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), + [3085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1172), + [3087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [3089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [3091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [3093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [3095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [3097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), + [3099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), + [3101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), + [3103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), + [3105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [3107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), + [3109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(780), + [3111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(788), + [3113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), + [3115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), + [3119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [3121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), + [3123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [3125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), + [3127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_arguments, 3, 0, 34), + [3129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), + [3131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), + [3133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), + [3135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(793), + [3137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), + [3139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), + [3143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), + [3145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [3147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), + [3149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 36), + [3151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 37), + [3153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [3155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [3157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), + [3159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1506), + [3161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), + [3163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), + [3165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), + [3167] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [3169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [3171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), + [3173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [3175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [3177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [3179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [3181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [3183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), + [3185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), + [3187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), + [3189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [3191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [3195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), + [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), + [3201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [3203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [3205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), + [3207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), + [3209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), + [3211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), + [3213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), + [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), + [3217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), + [3221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), + [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), + [3225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), + [3227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), + [3229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), + [3231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [3233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1185), + [3235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), + [3237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), + [3239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), + [3241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), + [3243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), + [3245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1599), + [3247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(820), + [3249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [3251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1607), + [3253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1341), + [3255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [3257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), + [3259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1617), + [3261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [3263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [3265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1626), + [3267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1628), + [3269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [3271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1633), + [3273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), + [3275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), + [3277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [3279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1230), + [3281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [3283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1665), + [3285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), + [3287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), + [3289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1672), + [3291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), + [3295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), + [3297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), + [3299] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), + [3301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [3303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [3305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1699), + [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), + [3309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1359), + [3311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1704), + [3313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), + [3315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1707), + [3317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1363), + [3319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), + [3321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), + [3323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1752), + [3325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [3327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1722), + [3329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [3331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [3333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), + [3337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [3339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [3341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), + [3343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), + [3345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [3347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [3349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), }; enum ts_external_scanner_symbol_identifiers { From 3c61aa571db9444fc206c9997c06bcde45a2faf1 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:30:52 +1000 Subject: [PATCH 06/10] fixes --- crates/osprey-cli/src/main.rs | 8 + crates/osprey-codegen/src/expr.rs | 9 +- crates/osprey-types/src/check.rs | 33 ++- crates/osprey-types/src/effect_rows.rs | 101 +++++++-- crates/osprey-types/src/env.rs | 13 +- crates/osprey-types/src/expr.rs | 29 ++- crates/osprey-types/src/info.rs | 36 +++- crates/osprey-types/src/lib.rs | 9 +- crates/osprey-types/src/redundant.rs | 234 +++++++++++++++++++++ crates/osprey-types/src/redundant_sites.rs | 186 ++++++++++++++++ crates/osprey-types/src/redundant_tests.rs | 223 ++++++++++++++++++++ docs/specs/0004-TypeSystem.md | 82 +++++++- 12 files changed, 918 insertions(+), 45 deletions(-) create mode 100644 crates/osprey-types/src/redundant.rs create mode 100644 crates/osprey-types/src/redundant_sites.rs create mode 100644 crates/osprey-types/src/redundant_tests.rs diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index 31f09be7..c73a46a4 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -464,11 +464,19 @@ fn dispatch(cli: &Cli, input: &CompilationInput) -> ExitCode { /// Type-check `program`, print every error in `file:line:col: message` form, /// and return how many there were. The shared gate for every compiling mode. +/// +/// Warnings print alongside the errors and are deliberately not counted: a +/// redundant annotation is a defect to delete, never a reason to fail a build +/// ([TYPE-ANNOTATION-REDUNDANT]). pub(crate) fn report_type_errors(input: &CompilationInput) -> usize { let errors = osprey_types::check_program(input.program()); for e in &errors { eprintln!("{}", input.diagnostic(e.position, &e.message)); } + for warning in osprey_types::redundant_annotations(input.program()) { + let text = format!("warning: {}", warning.message); + eprintln!("{}", input.diagnostic(warning.position, &text)); + } errors.len() } diff --git a/crates/osprey-codegen/src/expr.rs b/crates/osprey-codegen/src/expr.rs index 8a17dad6..a0818360 100644 --- a/crates/osprey-codegen/src/expr.rs +++ b/crates/osprey-codegen/src/expr.rs @@ -807,8 +807,13 @@ fn gen_call( arguments: &[Expr], named: &[NamedArgument], ) -> Result { - if let Expr::TypeApply { function, .. } = function { - return gen_call(cg, function, arguments, named); + if let Expr::TypeApply { function, position, .. } = function { + let bindings = position.and_then(|p| cg.prog.applications.get(&(p.line, p.column))).cloned().unwrap_or_default(); + let specialized = cg.prog.specialized(&bindings); + let original = std::mem::replace(&mut cg.prog, specialized); + let result = gen_call(cg, function, arguments, named); + cg.prog = original; + return result; } // A directly-applied lambda (`x |> fn(y) => …`, `(fn(y) => …)(x)`) is // beta-reduced inline. diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index d3db158a..12f1a50d 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -129,6 +129,10 @@ pub struct Checker { /// representation from, so this table is its only source of one. Resolved /// and published by [`infer_program`]. pub(crate) list_tys: Vec<(Position, Type)>, + /// Fresh substitutions at value uses, retained for the effect proof. + pub(crate) instantiations: HashMap>, + /// Explicit applications have stable source positions for backend cloning. + pub(crate) application_tys: Vec<(Position, HashMap)>, /// Concrete arguments passed to representation-sensitive built-ins. These /// are validated after inference so a variable constrained later in the /// same body is checked at its final type. @@ -188,6 +192,8 @@ impl Checker { lambda_tys: Vec::new(), let_tys: Vec::new(), list_tys: Vec::new(), + instantiations: HashMap::new(), + application_tys: Vec::new(), builtin_uses: Vec::new(), discards: Vec::new(), builtins: HashSet::new(), @@ -713,7 +719,7 @@ impl Checker { let fun_ty = Type::fun(params, ret); let declared = env .applied(&mut self.ctx, name) - .map(|(_, _, ps)| ps) + .map(|applied| applied.params) .unwrap_or_default(); env.remove(name); let mut scheme = self.generalize_with_obligations(env, &fun_ty); @@ -1165,6 +1171,12 @@ pub fn infer_program(program: &Program) -> crate::info::ProgramTypes { lists, performs, handler_ops, + applications: checker.application_tys.iter().map(|(position, bindings)| { + ((position.line, position.column), bindings.iter().map(|(var, ty)| (*var, checker.ctx.apply(ty))).collect()) + }).collect(), + declared_params: checker.fn_typarams.iter().map(|(name, bindings)| { + (name.clone(), bindings.iter().map(|(name, ty)| (name.clone(), checker.ctx.apply(ty))).collect()) + }).collect(), } } @@ -1196,7 +1208,10 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker /// Publish the current inference solution for the closed-program effect proof. fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { - let concrete_arguments = checker + let substitutions: HashMap<_, HashMap<_, _>> = checker.instantiations.iter().map(|(site, bindings)| { + (*site, bindings.iter().map(|(var, ty)| (*var, checker.ctx.apply(ty))).collect()) + }).collect(); + let resolved_arguments: Vec> = checker .perform_tys .clone() .into_iter() @@ -1205,8 +1220,12 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { .map(|arg| checker.ctx.apply(arg)) .collect::>() }) + .collect(); + let concrete_arguments = resolved_arguments.iter().cloned().chain(substitutions.values().flat_map(|bindings| { + resolved_arguments.iter().map(move |args| args.iter().map(|arg| crate::env::subst_vars(arg, bindings)).collect()) + })) .filter(|args| args.iter().all(type_is_resolved)) - .map(|args| args.iter().map(ToString::to_string).collect()) + .map(|args| (args.iter().map(ToString::to_string).collect(), args)) .collect(); let perform_tys = checker.perform_tys.clone(); let perform_actual_tys = checker.perform_actual_tys.clone(); @@ -1262,6 +1281,8 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { })), concrete_arguments, + instantiations: substitutions.into_iter().map(|(site, bindings)| (site, bindings.into_iter().map(|(var, ty)| (Type::Var(var).to_string(), ty.to_string())).collect())).collect(), + binders: checker.fn_typarams.iter().map(|(name, binders)| (name.clone(), binders.iter().map(|(name, ty)| (name.clone(), checker.ctx.apply(ty).to_string())).collect())).collect(), ..Default::default() } } @@ -1295,9 +1316,9 @@ fn refine_handler_arguments( if arguments.len() != choice.len() { continue; } - for (argument, concrete) in arguments.iter().zip(choice) { - let ty = type_name_to_type(concrete, &HashMap::new()); - checker.push_unify(argument, &ty); + let Some(types) = instances.concrete_arguments.get(choice) else { continue; }; + for (argument, concrete) in arguments.iter().zip(types) { + checker.push_unify(argument, concrete); } } checker.ctx.bound_count() != before diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index c1d5c58e..28fd6590 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -26,10 +26,12 @@ pub(crate) struct Instances { pub(crate) performs: HashMap<(u32, u32), Vec>>, pub(crate) handlers: HashMap<(u32, u32), Vec>, /// Fully resolved operation arguments available to refine a handler. - pub(crate) concrete_arguments: HashSet>, + pub(crate) concrete_arguments: HashMap, Vec>, /// Candidate instantiations required by each handler's body after calls /// and callbacks have propagated through the closed-program summary. pub(crate) handler_inference: RefCell, + pub(crate) instantiations: HashMap>, + pub(crate) binders: HashMap>, } #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] @@ -154,19 +156,19 @@ struct DeclaredEffect { } #[derive(Clone)] -struct Function { +struct Function<'a> { name: String, qualified: String, scope: Vec, parameters: Vec, declared_effects: Vec, - body: Expr, + body: &'a Expr, position: Option, } #[derive(Default)] -struct Index { - functions: Vec, +struct Index<'a> { + functions: Vec>, qualified: HashMap, bare: HashMap>, effects: HashMap, @@ -176,14 +178,14 @@ struct Index { externs: HashSet, } -impl Index { - fn collect(program: &Program) -> Self { +impl<'a> Index<'a> { + fn collect(program: &'a Program) -> Self { let mut index = Self::default(); index.collect_stmts(&program.statements, &[]); index } - fn collect_stmts(&mut self, statements: &[Stmt], scope: &[String]) { + fn collect_stmts(&mut self, statements: &'a [Stmt], scope: &[String]) { for statement in statements { match statement { Stmt::Extern { name, .. } => { @@ -223,7 +225,7 @@ impl Index { }), }) .collect(), - body: body.clone(), + body, position: *position, }); let _ = self.qualified.insert(qualified, id); @@ -261,7 +263,7 @@ impl Index { } } - fn collect_module_items(&mut self, items: &[ModuleItem], scope: &[String]) { + fn collect_module_items(&mut self, items: &'a [ModuleItem], scope: &[String]) { for item in items { self.collect_stmts(std::slice::from_ref(item.declaration.as_ref()), scope); } @@ -412,7 +414,7 @@ impl CallableEnv { } struct Analyzer<'a> { - index: &'a Index, + index: &'a Index<'a>, rows: &'a [Summary], returns: &'a [Option], instances: &'a Instances, @@ -478,7 +480,7 @@ impl Analyzer<'_> { env } - fn function_body(&self, function: &Function) -> Summary { + fn function_body(&self, function: &Function<'_>) -> Summary { self.expression( &function.body, &function.scope, @@ -486,7 +488,7 @@ impl Analyzer<'_> { ) } - fn function_return(&self, function: &Function) -> Option { + fn function_return(&self, function: &Function<'_>) -> Option { let mut env = self.scoped_env(&function.parameters); self.returned_value(&function.body, &function.scope, &mut env) } @@ -658,7 +660,7 @@ impl Analyzer<'_> { if let Some(position) = position { let candidates = body_summary.required.iter().filter(|requirement| { requirement.effect == *effect && handled.contains(&requirement.operation) - && self.instances.concrete_arguments.contains(&requirement.arguments) + && self.instances.concrete_arguments.contains_key(&requirement.arguments) }).map(|requirement| requirement.arguments.clone()); self.instances.handler_inference.borrow_mut() .entry((position.line, position.column)).or_default().extend(candidates); @@ -995,11 +997,19 @@ impl Analyzer<'_> { payload } + fn value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { + let mut value = self.raw_value(expression, scope, env)?; + if let Some(bindings) = self.instances.instantiations.get(&std::ptr::from_ref(expression).addr()) { + specialize_value(&mut value, bindings); + } + Some(value) + } + #[expect( clippy::too_many_lines, reason = "value provenance mirrors the exhaustive expression fold" )] - fn value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { + fn raw_value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { match expression { Expr::TypeApply { function, .. } => self.value(function, scope, env), Expr::Identifier(name) => { @@ -1592,7 +1602,7 @@ fn expression_name(expression: &Expr) -> Option<&str> { /// Trusting every unshadowed name let `let siren = ring` / `fn relay() = /// siren()` type-check with `Alarm.ring` never handled, because the call /// contributed nothing at all, not even a provenance failure. -fn statically_named_callee(expression: &Expr, env: &CallableEnv, index: &Index) -> bool { +fn statically_named_callee(expression: &Expr, env: &CallableEnv, index: &Index<'_>) -> bool { match expression { Expr::TypeApply { function, .. } => statically_named_callee(function, env, index), Expr::Identifier(name) => { @@ -1915,7 +1925,7 @@ fn merge_callable(slot: &mut Option, incoming: Callable) { }))); } -fn bind_pattern(pattern: &Pattern, value: Option<&Value>, index: &Index, env: &mut CallableEnv) { +fn bind_pattern(pattern: &Pattern, value: Option<&Value>, index: &Index<'_>, env: &mut CallableEnv) { match pattern { Pattern::Binding(name) | Pattern::TypeAnnotated { name, .. } => { let _ = env.shadowed.insert(name.clone()); @@ -1987,7 +1997,7 @@ fn bind_pattern(pattern: &Pattern, value: Option<&Value>, index: &Index, env: &m fn advance_function( analyzer: &Analyzer<'_>, id: usize, - function: &Function, + function: &Function<'_>, rows: &mut [Summary], returns: &mut [Option], ) -> bool { @@ -2028,7 +2038,7 @@ fn advance_function( /// that has not been walked yet, so one pass is a complete answer for the rows /// it was given. The enclosing fixed point re-derives it as those rows sharpen. fn file_scope_env( - index: &Index, + index: &Index<'_>, instances: &Instances, statements: &[Stmt], rows: &[Summary], @@ -2049,7 +2059,7 @@ fn file_scope_env( /// Least fixed point over every function's row and return provenance: /// recursive and forward calls only add requirements. fn converge( - index: &Index, + index: &Index<'_>, instances: &Instances, statements: &[Stmt], rows: &mut Vec, @@ -2120,6 +2130,49 @@ fn clear_value_verdicts(value: &mut Value) { } } +/// Substitute complete type-name tokens, so `t3` never rewrites `t30`. +fn specialize_argument(argument: &str, bindings: &HashMap) -> String { + let mut result = String::new(); + let mut token = String::new(); + for character in argument.chars().chain(std::iter::once('\0')) { + if character.is_alphanumeric() || character == '_' { + token.push(character); + } else { + result.push_str(bindings.get(&token).unwrap_or(&token)); + token.clear(); + if character != '\0' { result.push(character); } + } + } + result +} + +fn specialize_requirements(requirements: &mut Requirements, bindings: &HashMap) { + *requirements = std::mem::take(requirements).into_iter().map(|mut requirement| { + requirement.arguments = requirement.arguments.iter().map(|arg| specialize_argument(arg, bindings)).collect(); + requirement + }).collect(); +} + +fn specialize_summary(summary: &mut Summary, bindings: &HashMap) { + specialize_requirements(&mut summary.required, bindings); + summary.parameter_uses = std::mem::take(&mut summary.parameter_uses).into_iter().map(|mut use_| { + specialize_requirements(&mut use_.excluded, bindings); + use_ + }).collect(); +} + +fn specialize_value(value: &mut Value, bindings: &HashMap) { + specialize_summary(&mut value.deferred, bindings); + if let Some(Callable::Known(known)) = &mut value.callable { + specialize_summary(&mut known.summary, bindings); + if let Some(returned) = &mut known.returned { specialize_value(returned, bindings); } + } + for nested in value.fields.values_mut() { specialize_value(nested, bindings); } + for nested in [value.element.as_mut(), value.result_payload.as_mut(), value.fiber_payload.as_mut()].into_iter().flatten() { + specialize_value(nested, bindings); + } +} + /// Check inferred rows and entry discharge. Implements /// [EFFECTS-STATIC-DISCHARGE]. #[expect( @@ -2218,7 +2271,11 @@ pub(crate) fn check(program: &Program, instances: &Instances, exports: &[&str]) && declared .arguments .as_ref() - .is_none_or(|arguments| arguments == &requirement.arguments) + .is_none_or(|arguments| { + let bindings = instances.binders.get(&function.name); + arguments.iter().map(|arg| bindings.map_or_else(|| arg.clone(), |b| specialize_argument(arg, b))) + .eq(requirement.arguments.iter().cloned()) + }) }) }) .map(requirement_name) @@ -2527,7 +2584,7 @@ fn fibered_operation( /// happens. Over-reaching costs a rejection the plan already fails closed on; /// under-reaching would miss the fiber boundary this rule exists to find. fn reachable_bodies<'a>( - index: &'a Index, + index: &'a Index<'_>, body: &'a Expr, scope: &'a [String], ) -> Vec<(&'a Expr, &'a [String])> { diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index 3b9cfbb2..fc792c67 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -8,7 +8,12 @@ use crate::ty::{Scheme, Type, VarId}; use std::collections::{BTreeSet, HashMap, HashSet}; /// One call's signature, deferred obligations, and ordered declared binders. -pub(crate) type AppliedSignature = (Type, Vec<(String, Type)>, Vec); +pub(crate) struct AppliedSignature { + pub ty: Type, + pub obligations: Vec<(String, Type)>, + pub params: Vec, + pub bindings: HashMap, +} /// Maps names to their type schemes. Cloned to form child scopes (lambda /// bodies, match arms) — value semantics, so child bindings never leak out. @@ -82,7 +87,9 @@ impl TypeEnv { .iter() .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))) .collect(); - Some((subst_vars(&scheme.ty, &map), obligations, params)) + Some(AppliedSignature { + ty: subst_vars(&scheme.ty, &map), obligations, params, bindings: map, + }) } /// A fresh child scope (a clone — bindings added to the child don't leak). @@ -143,7 +150,7 @@ pub fn generalize(ctx: &mut InferCtx, env: &TypeEnv, ty: &Type) -> Scheme { } } -fn subst_vars(t: &Type, map: &HashMap) -> Type { +pub(crate) fn subst_vars(t: &Type, map: &HashMap) -> Type { match t { Type::Var(v) => map.get(v).cloned().unwrap_or_else(|| t.clone()), Type::Con { name, args } => Type::Con { diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index 57b94486..fc3fbf4e 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -55,8 +55,8 @@ impl Checker { } Type::string() } - Expr::Identifier(name) => self.lookup_ident(name, env), - Expr::Path(path) => self.lookup_ident(&path.to_string(), env), + Expr::Identifier(name) => self.lookup_ident_at(name, env, Some(e)), + Expr::Path(path) => self.lookup_ident_at(&path.to_string(), env, Some(e)), Expr::List(items, position) => { let elem = self.ctx.fresh(); for it in items { @@ -526,6 +526,10 @@ impl Checker { } fn lookup_ident(&mut self, name: &str, env: &TypeEnv) -> Type { + self.lookup_ident_at(name, env, None) + } + + fn lookup_ident_at(&mut self, name: &str, env: &TypeEnv, site: Option<&Expr>) -> Type { // A bare nullary constructor (`Red`, `Empty`) is a value of its owner type. if self.ctors.get(name).is_some_and(|i| i.fields.is_empty()) { if let Some((args, _f, owner, is_record)) = self.ctor_instance(name) { @@ -539,14 +543,16 @@ impl Checker { }; } } - if let Some(scheme) = env.get(name).cloned() { + if let Some(applied) = env.applied(&mut self.ctx, name) { // Re-state the scheme's built-in obligations against this site's // fresh variables, so a generalized wrapper's constraint is checked // against the types this call actually supplies // ([`crate::ty::Scheme::obligations`]). - let (ty, obligations) = crate::env::instantiated(&mut self.ctx, &scheme); - self.builtin_uses.extend(obligations); - return ty; + self.builtin_uses.extend(applied.obligations); + if let Some(site) = site { + let _ = self.instantiations.insert(std::ptr::from_ref(site).addr(), applied.bindings); + } + return applied.ty; } self.errors .push(TypeError::new(format!("unknown identifier `{name}`"))); @@ -572,10 +578,10 @@ impl Checker { type_args, position, } => self.infer_type_application(function, type_args, *position, env), - Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident(name, env)), + Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident_at(name, env, Some(function))), Expr::Path(path) => { let name = path.to_string(); - let ty = self.lookup_ident(&name, env); + let ty = self.lookup_ident_at(&name, env, Some(function)); (Some(name), ty) } other => (None, self.infer_expr(other, env)), @@ -599,10 +605,15 @@ impl Checker { return (None, self.infer_expr(function, env)); } }; - let Some((ty, obligations, params)) = env.applied(&mut self.ctx, &name) else { + let Some(applied) = env.applied(&mut self.ctx, &name) else { return (Some(name.clone()), self.lookup_ident(&name, env)); }; + let crate::env::AppliedSignature { ty, obligations, params, bindings } = applied; self.builtin_uses.extend(obligations); + if let Some(position) = position { + self.application_tys.push((position, bindings.clone())); + } + let _ = self.instantiations.insert(std::ptr::from_ref(function).addr(), bindings); if params.len() == type_args.len() { let binder = self.current_fn_typarams.clone(); for (param, arg) in params.iter().zip(type_args) { diff --git a/crates/osprey-types/src/info.rs b/crates/osprey-types/src/info.rs index 23c3372f..67d8e772 100644 --- a/crates/osprey-types/src/info.rs +++ b/crates/osprey-types/src/info.rs @@ -3,7 +3,7 @@ //! union tags are then frozen into the plain, substitution-free tables below //! so the backend can drive codegen off real types instead of guessing `i64`. -use crate::ty::{names, Type}; +use crate::ty::{names, Type, VarId}; use std::collections::HashMap; /// The declared shape of a record/variant constructor: ordered `(field, type)` @@ -71,6 +71,10 @@ pub struct ProgramTypes { /// handler-arm view of the same instantiation data). Implements /// [EFFECTS-GENERIC-INSTANTIATION]. pub handler_ops: HashMap<(u32, u32), HandlerSite>, + /// Explicit call substitutions, applied while specializing generic bodies. + pub applications: HashMap<(u32, u32), HashMap>, + /// Binder identity is part of the contract even when its spelling is omitted. + pub(crate) declared_params: HashMap>, } /// One `perform` site's resolved instantiation. @@ -92,6 +96,36 @@ pub struct HandlerSite { } impl ProgramTypes { + /// Specialize inferred body metadata with one call's type substitution. + /// Constructor and effect declarations retain their shared erased ABI. + #[must_use] + pub fn specialized(&self, bindings: &HashMap) -> Self { + let mut result = self.clone(); + let substitute = |ty: &mut Type| *ty = crate::env::subst_vars(ty, bindings); + for (params, ret) in result.functions.values_mut() { + params.iter_mut().for_each(&substitute); + substitute(ret); + } + for table in [&mut result.lambdas, &mut result.lets, &mut result.lists] { + table.values_mut().for_each(&substitute); + } + for site in result.performs.values_mut() { + site.effect_args.iter_mut().for_each(&substitute); + site.op.params.iter_mut().for_each(&substitute); + substitute(&mut site.op.ret); + } + for site in result.handler_ops.values_mut() { + site.effect_args.iter_mut().for_each(&substitute); + for op in site.ops.values_mut() { + op.params.iter_mut().for_each(&substitute); + substitute(&mut op.ret); + } + } + for args in result.applications.values_mut() { args.values_mut().for_each(&substitute); } + for args in result.declared_params.values_mut() { args.values_mut().for_each(&substitute); } + result + } + /// The resolved return type of a named function, if known. #[must_use] pub fn return_type(&self, name: &str) -> Option<&Type> { diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index b3c5b955..9e41039d 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -9,7 +9,9 @@ //! [`check::check_program`] driver over the AST. //! //! Public surface: [`check_program`] takes a parsed [`osprey_ast::Program`] and -//! returns the list of [`TypeError`]s (empty ⇒ well-typed). +//! returns the list of [`TypeError`]s (empty ⇒ well-typed); +//! [`redundant_annotations`] returns the [`TypeWarning`]s for annotations the +//! inferrer would have derived on its own ([TYPE-ANNOTATION-REDUNDANT]). mod builtin_constraints; mod builtin_docs; @@ -49,6 +51,10 @@ mod info; mod init_order; mod multiplicity; mod pattern; +mod redundant; +mod redundant_sites; +#[cfg(test)] +mod redundant_tests; #[cfg(test)] mod testutil; mod ty; @@ -62,6 +68,7 @@ pub use builtins::{builtin_callback_type, builtin_signature}; pub use check::{check_program, check_program_exports, erased_var, infer_program}; pub use error::TypeError; pub use info::{CtorLayout, HandlerSite, OpType, PerformSite, ProgramTypes}; +pub use redundant::{redundant_annotations, TypeWarning, REDUNDANT_ANNOTATION}; pub use ty::{has_type_var, names, render_with_holes, Scheme, Type, VarId, HOLE}; #[cfg(test)] diff --git a/crates/osprey-types/src/redundant.rs b/crates/osprey-types/src/redundant.rs new file mode 100644 index 00000000..5b53789e --- /dev/null +++ b/crates/osprey-types/src/redundant.rs @@ -0,0 +1,234 @@ +//! Redundant type-annotation detection. +//! +//! Implements [TYPE-ANNOTATION-REDUNDANT]. An annotation is redundant exactly +//! when erasing it leaves the solved program unchanged, which is a property of +//! inference and not of the annotation's spelling: the same +//! `string -> int -> string` is redundant on one function and load-bearing on +//! the next. The rule is therefore decided by re-running the inferrer over an +//! erased copy of the program and comparing what it published. + +use std::collections::{BTreeMap, HashMap}; + +use osprey_ast::{Position, Program}; + +use crate::check::{check_program, infer_program}; +use crate::redundant_sites::{erase, sites, Site, Slot}; +use crate::ty::{Type, VarId}; + +/// The rule identifier this diagnostic is reported under, and the name a +/// per-rule severity setting will address it by ([TYPE-ANNOTATION-REDUNDANT]). +pub const REDUNDANT_ANNOTATION: &str = "redundant-annotation"; + +/// A diagnostic that is true of the program but is not a reason to reject it. +/// +/// Warnings are reported alongside [`TypeError`](crate::TypeError)s and change +/// no exit code and no generated code. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TypeWarning { + /// Human-readable text, already naming the offending declaration. + pub message: String, + /// Where the annotated declaration was written, when recorded. + pub position: Option, + /// The rule that raised it. + pub rule: &'static str, +} + +/// Every type the inferrer publishes, under a stable label. +/// +/// Function signatures are keyed by name; bindings, lambdas and list literals +/// are keyed by source position, which an erasure never moves. Comparing the +/// whole map is what makes the rule honest: an annotation that changed only a +/// `let`'s type is still an annotation that changed something. +type Published = BTreeMap; + +/// Every redundant annotation in `program`, in source order. +/// +/// An ill-typed program yields none: its inferred types are the checker's +/// best effort at a program that does not typecheck, so no conclusion drawn +/// from comparing them would be trustworthy. +#[must_use] +pub fn redundant_annotations(program: &Program) -> Vec { + if !check_program(program).is_empty() { + return Vec::new(); + } + let written = sites(program); + if written.is_empty() { + return Vec::new(); + } + let baseline = published(program); + if preserves(&baseline, &erase(program, &mut |_| false)) { + return written.iter().map(warn).collect(); + } + attribute(program, &baseline, &written) +} + +/// Test each annotation on its own, once erasing all of them at once has been +/// ruled out. One of them is load-bearing; only re-solving with exactly one +/// removed says which. +fn attribute(program: &Program, baseline: &Published, written: &[Site]) -> Vec { + written + .iter() + .enumerate() + .filter(|(index, _)| preserves(baseline, &erase(program, &mut |site| site != *index))) + .map(|(_, site)| warn(site)) + .collect() +} + +/// Whether `candidate` — `program` minus some annotations — still typechecks +/// and still publishes the same types, up to renaming of type variables. +fn preserves(baseline: &Published, candidate: &Program) -> bool { + check_program(candidate).is_empty() && same_types(baseline, &published(candidate)) +} + +/// Everything the inferrer resolved, labelled so two runs compare entry by +/// entry. +fn published(program: &Program) -> Published { + let types = infer_program(program); + let functions = types.functions.iter().map(|(name, (params, ret))| { + let signature = Type::Fun { + params: params.clone(), + ret: Box::new(ret.clone()), + }; + (format!("fn {name}"), signature) + }); + functions + .chain(sited("let", &types.lets)) + .chain(sited("lambda", &types.lambdas)) + .chain(sited("list", &types.lists)) + .collect() +} + +/// Label one position-keyed table so its entries join the same flat map. +fn sited<'a>( + kind: &'a str, + table: &'a HashMap<(u32, u32), Type>, +) -> impl Iterator + 'a { + table + .iter() + .map(move |((line, column), ty)| (format!("{kind} {line}:{column}"), ty.clone())) +} + +/// The diagnostic for one redundant annotation. +/// +/// The reported type is the written one: redundancy *means* inference derives +/// exactly that, so printing it tells the reader the deletion is a no-op. +fn warn(site: &Site) -> TypeWarning { + let written = &site.written; + let message = match &site.slot { + Slot::Param { owner, parameter } => format!( + "redundant type annotation on parameter `{parameter}` of `{owner}`: inference derives `{written}` without it" + ), + Slot::Return { owner } => format!( + "redundant return type annotation on `{owner}`: inference derives `{written}` without it" + ), + Slot::Binding { name } => format!( + "redundant type annotation on `{name}`: inference derives `{written}` without it" + ), + }; + TypeWarning { + message, + position: site.position, + rule: REDUNDANT_ANNOTATION, + } +} + +/// Whether two runs published the same types up to a consistent renaming of +/// inference variables. +/// +/// The renaming is global rather than per entry: a shared variable is real +/// sharing between two signatures, and an erasure that breaks it changed the +/// program's types even though each signature alone still looks the same. +fn same_types(left: &Published, right: &Published) -> bool { + let mut renaming = Renaming::default(); + left.len() == right.len() + && left + .iter() + .zip(right.iter()) + .all(|((left_label, left_ty), (right_label, right_ty))| { + left_label == right_label && equivalent(left_ty, right_ty, &mut renaming) + }) +} + +/// A partial bijection between the two runs' inference variables. +#[derive(Default)] +struct Renaming { + /// Left variable → the right variable it was first paired with. + forward: HashMap, + /// Right variable → the left variable it was first paired with. + backward: HashMap, +} + +impl Renaming { + /// Pair `left` with `right`, failing if either is already paired elsewhere. + fn pair(&mut self, left: VarId, right: VarId) -> bool { + matches(&mut self.forward, left, right) && matches(&mut self.backward, right, left) + } +} + +/// Whether `key` already maps to `value` in `map`, recording it if it is new. +fn matches(map: &mut HashMap, key: VarId, value: VarId) -> bool { + match map.insert(key, value) { + Some(existing) => existing == value, + None => true, + } +} + +/// Whether two types are equal up to the variable renaming built so far. +fn equivalent(left: &Type, right: &Type, renaming: &mut Renaming) -> bool { + match (left, right) { + (Type::Var(l), Type::Var(r)) => renaming.pair(*l, *r), + (Type::Con { name: l, args: la }, Type::Con { name: r, args: ra }) + | ( + Type::Union { + name: l, + variants: la, + }, + Type::Union { + name: r, + variants: ra, + }, + ) => l == r && all_equivalent(la, ra, renaming), + ( + Type::Fun { + params: lp, + ret: lr, + }, + Type::Fun { + params: rp, + ret: rr, + }, + ) => all_equivalent(lp, rp, renaming) && equivalent(lr, rr, renaming), + ( + Type::Record { + name: l, + fields: lf, + }, + Type::Record { + name: r, + fields: rf, + }, + ) => l == r && lf.keys().eq(rf.keys()) && all_equivalent_values(lf, rf, renaming), + _ => false, + } +} + +/// Whether two type sequences are pairwise equivalent under one renaming. +fn all_equivalent(left: &[Type], right: &[Type], renaming: &mut Renaming) -> bool { + left.len() == right.len() + && left + .iter() + .zip(right.iter()) + .all(|(l, r)| equivalent(l, r, renaming)) +} + +/// Whether two records' field types are pairwise equivalent. Fields are keyed +/// in a `BTreeMap`, so iteration already aligns them by name. +fn all_equivalent_values( + left: &BTreeMap, + right: &BTreeMap, + renaming: &mut Renaming, +) -> bool { + left.values() + .zip(right.values()) + .all(|(l, r)| equivalent(l, r, renaming)) +} diff --git a/crates/osprey-types/src/redundant_sites.rs b/crates/osprey-types/src/redundant_sites.rs new file mode 100644 index 00000000..68903849 --- /dev/null +++ b/crates/osprey-types/src/redundant_sites.rs @@ -0,0 +1,186 @@ +//! Locating and erasing written type annotations. +//! +//! Implements [TYPE-ANNOTATION-REDUNDANT]: the rule is decided by re-inferring +//! a program with one annotation replaced by a fresh variable, so the detector +//! needs a way to address each annotation and produce that erased copy. Both +//! needs are one deterministic pre-order walk over the same slots, so this +//! module exposes exactly one traversal and two thin drivers over it. + +use std::collections::HashMap; + +use osprey_ast::mutate::{children_mut, statement_children_mut}; +use osprey_ast::{Expr, Position, Program, Stmt, TypeExpr}; + +use crate::convert::type_expr_to_type; + +/// What a written annotation is attached to, for the diagnostic's wording. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum Slot { + /// A named function or lambda parameter. + Param { + /// The enclosing function's name (`` for an anonymous one). + owner: String, + /// The annotated parameter's name. + parameter: String, + }, + /// A function's or lambda's declared return type. + Return { + /// The enclosing function's name (`` for an anonymous one). + owner: String, + }, + /// A `let` binding's declared type. + Binding { + /// The bound name. + name: String, + }, +} + +/// The name reported for an annotation written on an anonymous function. +const LAMBDA_OWNER: &str = ""; + +/// One written annotation, addressed by its index in the pre-order walk. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct Site { + /// What the annotation is attached to. + pub(crate) slot: Slot, + /// The written type, rendered. Redundancy means inference derives exactly + /// this, so it is also the type the diagnostic reports as derived. + pub(crate) written: String, + /// Where the annotated declaration was written, when recorded. + pub(crate) position: Option, +} + +/// The callback every traversal function here threads through the tree: it +/// receives each annotation slot and the annotation itself, by unique +/// reference so a driver can clear it in place. +type Visit<'a> = &'a mut dyn FnMut(Slot, Option, &mut Option); + +/// Every written annotation the rule judges, in walk order. +/// +/// The index of a [`Site`] in this list is its address: [`erase`] clears the +/// annotation the same walk reaches at the same index. +pub(crate) fn sites(program: &Program) -> Vec { + let mut found = Vec::new(); + let mut scratch = program.clone(); + walk(&mut scratch, &mut |slot, position, annotation| { + if let Some(written) = annotation.as_ref().map(render) { + found.push(Site { + slot, + written, + position, + }); + } + }); + found +} + +/// A copy of `program` with the annotations selected by `keep` removed. +/// +/// `keep` is called with each site's walk index and returns `true` to leave the +/// annotation in place, so erasing one site and erasing every site are the same +/// traversal under two predicates. +pub(crate) fn erase(program: &Program, keep: &mut impl FnMut(usize) -> bool) -> Program { + let mut erased = program.clone(); + let mut index = 0usize; + walk(&mut erased, &mut |_, _, annotation| { + if annotation.is_some() { + if !keep(index) { + *annotation = None; + } + index += 1; + } + }); + erased +} + +/// Render a written annotation the way inference renders the type it derives, +/// so a diagnostic's before and after are directly comparable. +fn render(annotation: &TypeExpr) -> String { + type_expr_to_type(annotation, &HashMap::new()).to_string() +} + +/// Hand every annotation slot in `program` to `visit`, in pre-order. +fn walk(program: &mut Program, visit: Visit<'_>) { + walk_statements(&mut program.statements, visit); +} + +/// Walk a statement sequence — a program body, a namespace, or a block. +fn walk_statements(statements: &mut [Stmt], visit: Visit<'_>) { + for statement in statements { + walk_statement(statement, &mut *visit); + } +} + +/// Walk one statement's own annotation slots, then the expressions inside it. +/// +/// A container statement recurses here and returns, because +/// [`statement_children_mut`] would otherwise reach the same nested statements +/// a second time and shift every later site's index. +fn walk_statement(statement: &mut Stmt, visit: Visit<'_>) { + match statement { + Stmt::Namespace { body, .. } => return walk_statements(body, &mut *visit), + Stmt::Module { body, .. } => { + for item in &mut *body { + walk_statement(&mut item.declaration, &mut *visit); + } + return; + } + Stmt::Function { + name, + parameters, + return_type, + position, + .. + } => walk_signature(name, parameters, return_type, *position, &mut *visit), + Stmt::Let { + name, ty, position, .. + } => visit(Slot::Binding { name: name.clone() }, *position, ty), + _ => {} + } + statement_children_mut(statement, &mut |expression| walk_expr(expression, &mut *visit)); +} + +/// Walk the annotation slots reachable through an expression. +/// +/// A block owns statements, which [`children_mut`] reaches only as their child +/// expressions, so a block recurses here instead of through that helper. +fn walk_expr(expression: &mut Expr, visit: Visit<'_>) { + if let Expr::Lambda { + parameters, + return_type, + position, + .. + } = expression + { + walk_signature(LAMBDA_OWNER, parameters, return_type, *position, &mut *visit); + } + if let Expr::Block { statements, value } = expression { + walk_statements(statements, &mut *visit); + if let Some(value) = value { + walk_expr(value, &mut *visit); + } + return; + } + children_mut(expression, &mut |child| walk_expr(child, &mut *visit)); +} + +/// Hand a callable's parameter and return annotations to `visit`, in order. +fn walk_signature( + owner: &str, + parameters: &mut [osprey_ast::Parameter], + return_type: &mut Option, + position: Option, + visit: Visit<'_>, +) { + for parameter in parameters { + let slot = Slot::Param { + owner: owner.to_string(), + parameter: parameter.name.clone(), + }; + visit(slot, position, &mut parameter.ty); + } + let slot = Slot::Return { + owner: owner.to_string(), + }; + visit(slot, position, return_type); +} diff --git a/crates/osprey-types/src/redundant_tests.rs b/crates/osprey-types/src/redundant_tests.rs new file mode 100644 index 00000000..35fc8e7e --- /dev/null +++ b/crates/osprey-types/src/redundant_tests.rs @@ -0,0 +1,223 @@ +//! Tests for [TYPE-ANNOTATION-REDUNDANT]. +//! +//! Every assertion here pins the exact diagnostic text, not a substring: the +//! message names the declaration and prints the type the reader would get by +//! deleting the annotation, and a message that stops being that precise is a +//! regression even when it still contains the word "redundant". + +use crate::redundant::{redundant_annotations, TypeWarning, REDUNDANT_ANNOTATION}; +use osprey_ast::Position; +use osprey_syntax::{parse_program_with_flavor, Flavor}; + +/// Parse under `flavor` and collect the redundancy warnings. A snippet that +/// does not parse fails the test rather than scoring as "no warnings". +fn warnings(flavor: Flavor, src: &str) -> Vec { + let parsed = parse_program_with_flavor(src, flavor); + assert!( + parsed.errors.is_empty(), + "{flavor} flavor rejected the snippet at parse time: {:?}\n{src}", + parsed.errors + ); + redundant_annotations(&parsed.program) +} + +/// The warning messages under `flavor`, in report order. +fn messages(flavor: Flavor, src: &str) -> Vec { + warnings(flavor, src) + .into_iter() + .map(|w| w.message) + .collect() +} + +/// Assert the exact set of messages `flavor` reports for `src`, in order. +fn reports(flavor: Flavor, src: &str, expected: &[&str]) { + assert_eq!(messages(flavor, src), expected, "\n{src}"); +} + +/// Assert `src` is clean under `flavor` — every annotation in it is earning +/// its place, or there are none. +fn silent(flavor: Flavor, src: &str) { + reports(flavor, src, &[]); +} + +const GREET: &str = "fn greet(name: string) -> string = \"hi \" + name\n"; + +#[test] +fn a_redundant_parameter_and_return_are_both_named_exactly() { + reports( + Flavor::Default, + GREET, + &[ + "redundant type annotation on parameter `name` of `greet`: inference derives `string` without it", + "redundant return type annotation on `greet`: inference derives `string` without it", + ], + ); +} + +#[test] +fn an_unannotated_function_reports_nothing() { + silent(Flavor::Default, "fn greet(name) = \"hi \" + name\n"); +} + +#[test] +fn every_warning_carries_the_configurable_rule_identifier() { + let raised = warnings(Flavor::Default, GREET); + assert_eq!(raised.len(), 2, "{raised:?}"); + assert!( + raised.iter().all(|w| w.rule == REDUNDANT_ANNOTATION), + "{raised:?}" + ); + assert_eq!(REDUNDANT_ANNOTATION, "redundant-annotation"); +} + +#[test] +fn a_warning_points_at_the_declaration_it_came_from() { + let raised = warnings(Flavor::Default, &format!("\n\n{GREET}")); + assert_eq!( + raised.first().map(|w| w.position), + Some(Some(Position { line: 3, column: 3 })), + "{raised:?}" + ); +} + +#[test] +fn a_redundant_let_annotation_is_reported_by_name() { + reports( + Flavor::Default, + "let n: int = 42\n", + &["redundant type annotation on `n`: inference derives `int` without it"], + ); +} + +#[test] +fn an_empty_literal_annotation_is_load_bearing_and_kept() { + silent(Flavor::Default, "let xs: List = []\n"); +} + +#[test] +fn a_redundant_lambda_parameter_is_reported_against_the_lambda() { + reports( + Flavor::Default, + "let exclaim = fn(s: string) => s + \"!\"\nlet r = exclaim(\"hi\")\n", + &["redundant type annotation on parameter `s` of ``: inference derives `string` without it"], + ); +} + +#[test] +fn an_extern_declaration_is_never_reported() { + // Implements [TYPE-ANNOTATION-REDUNDANT]: an `extern` has no body to infer + // from, so its types are its declaration and can never be redundant. + silent( + Flavor::Default, + "extern fn osprey_ffi_cell() -> Ptr\nlet c = osprey_ffi_cell()\n", + ); +} + +#[test] +fn record_field_declarations_are_never_reported() { + silent( + Flavor::Default, + "type Point = { x: int, y: int }\nlet p = Point { x: 1, y: 2 }\n", + ); +} + +#[test] +fn an_ill_typed_program_reports_no_redundancy() { + // Inference over a rejected program is a best-effort shape, so no + // comparison against it would be trustworthy. The type errors come first. + silent( + Flavor::Default, + "fn inc(x: int) -> int = x + 1\nlet r = inc(\"not an int\")\n", + ); +} + +#[test] +fn a_redundant_generic_signature_is_reported_with_its_binder() { + reports( + Flavor::Default, + "fn identity(x: T) -> T = x\nlet i = identity(42)\n", + &[ + "redundant type annotation on parameter `x` of `identity`: inference derives `T` without it", + "redundant return type annotation on `identity`: inference derives `T` without it", + ], + ); +} + +#[test] +fn a_result_returning_annotation_that_matches_inference_is_still_redundant() { + reports( + Flavor::Default, + "fn half(n: int) -> Result = intDiv(n, 2)\n", + &[ + "redundant type annotation on parameter `n` of `half`: inference derives `int` without it", + "redundant return type annotation on `half`: inference derives `Result` without it", + ], + ); +} + +#[test] +fn a_return_annotation_that_narrows_the_error_type_is_kept() { + // `intDiv` yields `Result`; the annotation names a different + // error type, so it is doing work and erasing it changes the signature. + silent( + Flavor::Default, + "fn half(n: int) -> Result = intDiv(n, 2)\n", + ); +} + +#[test] +fn ml_and_default_spellings_of_one_signature_report_identically() { + let default = messages(Flavor::Default, GREET); + let ml = messages(Flavor::Ml, "greet : string -> string\ngreet name = \"hi \" + name\n"); + assert_eq!(default, ml, "flavors disagreed about the same signature"); + assert_eq!(ml.len(), 2, "{ml:?}"); +} + +#[test] +fn an_ml_module_body_repeating_its_signature_is_still_redundant() { + // The `signature` block is the module's contract and is never reported; + // the body's copy of the same type is judged like any other function. + reports( + Flavor::Ml, + "signature Api\n shout : string -> string\n\nmodule M : Api\n shout : string -> string\n shout s = s + \"!\"\n", + &[ + "redundant type annotation on parameter `s` of `shout`: inference derives `string` without it", + "redundant return type annotation on `shout`: inference derives `string` without it", + ], + ); +} + +#[test] +fn a_signature_block_alone_reports_nothing() { + silent( + Flavor::Ml, + "signature Api\n shout : string -> string\n\nmodule M : Api\n shout s = s + \"!\"\n", + ); +} + +#[test] +fn two_redundant_functions_are_reported_in_source_order() { + reports( + Flavor::Default, + "fn first(a: string) -> string = a + \"1\"\nfn second(b: string) -> string = b + \"2\"\n", + &[ + "redundant type annotation on parameter `a` of `first`: inference derives `string` without it", + "redundant return type annotation on `first`: inference derives `string` without it", + "redundant type annotation on parameter `b` of `second`: inference derives `string` without it", + "redundant return type annotation on `second`: inference derives `string` without it", + ], + ); +} + +#[test] +fn a_nested_block_binding_is_reached() { + reports( + Flavor::Default, + "fn run() -> string = {\n let greeting: string = \"hi\"\n greeting\n}\n", + &[ + "redundant return type annotation on `run`: inference derives `string` without it", + "redundant type annotation on `greeting`: inference derives `string` without it", + ], + ); +} + diff --git a/docs/specs/0004-TypeSystem.md b/docs/specs/0004-TypeSystem.md index 124846f7..ae72fa98 100644 --- a/docs/specs/0004-TypeSystem.md +++ b/docs/specs/0004-TypeSystem.md @@ -11,6 +11,7 @@ - [Built-in Error Types](#built-in-error-types) - [The `any` Type](#the-any-type--type-any) - [Type Annotations](#type-annotations--type-annotation-check) +- [Redundant Annotations](#redundant-annotations--type-annotation-redundant) ## Hindley-Milner Inference @@ -46,7 +47,10 @@ compose (f, g) = \x => f (g x) // ((B)->C,(A)->B) -> (A)->C `add` follows [ARITH-CHECKED](0013-ErrorHandling.md#arithmetic--arith-checked): integer `+ - *` return `int`. With a `float` operand, the integer is promoted and the IEEE-754 operation returns plain `float`. Record fields and foreign declarations include types as part of their syntax; -annotations on bindings and functions constrain the inferred type. +annotations on bindings and functions constrain the inferred type. An +annotation that constrains nothing — one inference would have derived anyway — +is a defect the compiler reports +([TYPE-ANNOTATION-REDUNDANT](#redundant-annotations--type-annotation-redundant)). A polymorphic function is monomorphised independently at each call site: @@ -871,3 +875,79 @@ fn half(n: int) -> Result = intDiv(n, 2) Writing `-> int` for `half` would be a type error; a return annotation cannot erase the body's `Result` ([Result Preservation](#result-preservation)). + +## Redundant Annotations — [TYPE-ANNOTATION-REDUNDANT] + +An annotation the inferrer would have derived on its own carries no +information. It cannot change what the program means — by construction the +solver reaches the same type without it — so it can only go stale, disagree +with the body a later edit produces, and cost a reader a second reading to +confirm it says nothing. Osprey reports every one of them. + +**The rule.** A written type is *redundant* when erasing it leaves the solved +type unchanged. Redundancy is not a syntactic property and cannot be decided by +reading the annotation: `string -> int -> string` is redundant on one function +and load-bearing on the next. It is decided by inference, and only by +inference. + +**The decision procedure.** For each annotation, replace it with a fresh type +variable, solve the enclosing definition, and generalise. Compare the result to +the type that was written, up to renaming of bound type variables. Equal ⇒ +redundant. More general ⇒ the annotation was constraining something and is +kept. Ill-typed without it ⇒ kept. + +```mermaid +flowchart LR + A["written annotation"] --> B["erase → fresh var"] + B --> C["infer + generalise"] + C --> D{"solved type
vs written"} + D -- "alpha-equal" --> E["redundant — report"] + D -- "strictly more general" --> F["constraining — keep"] + D -- "no solution" --> F +``` + +**Where it applies.** Function parameter annotations, function return +annotations, lambda parameter annotations, and binding annotations, in both +surfaces ([FLAVOR-BOUNDARY]) — an ML `f : string -> int` header and a Default +`fn f(x: string) -> int` are the same canonical annotation and are judged +identically. + +```osprey-ml +// redundant: `quote key + ":" + toString value` already fixes every slot. +numField : string -> int -> string +numField key value = quote key + ":" + toString value + +// kept: the empty literal constrains nothing on its own. +seen : List +seen = [] +``` + +**What is never redundant.** Four constructs carry types as part of their +declaration rather than as a constraint on an inferred one, and no annotation +in them is ever reported: + +- a `signature` block's members ([MODULES-SIGNATURE](0025-ModulesAndNamespaces.md#signatures-modules-signature)) — a signature *is* the module's public contract, and a module body that repeats one of its types is judged like any other function; +- record field declarations and union variant payloads, whose types are their definition; +- `extern` and foreign declarations ([Foreign Function Interface](0019-ForeignFunctionInterface.md)), which have no body to infer from; +- an annotation whose erasure leaves a free type variable the solver never grounds. + +An annotation that would erase a `Result` is not redundant either — it is a +type error ([Result Preservation](#result-preservation)), reported as one. + +**Severity.** The diagnostic is a **Warning**. It changes no exit code and no +generated code: a program whose only diagnostics are redundant annotations +compiles and runs exactly as it did. Severity is fixed today and becomes +configurable per rule; the rule identifier is `redundant-annotation`, and it is +that identifier a future configuration names. + +**The message** identifies the annotation and prints the type inference derives +without it, so the fix is to delete the annotation and nothing else: + +``` +warning: redundant type annotation on `numField`: inference derives `(string, int) -> string` without it +``` + +Every front end reports it: `osprey build` and `osprey check` on stderr, and +the language server as a Warning diagnostic spanning the annotation alone +([LSP-DIAGNOSTICS](0020-LanguageServerAndEditors.md#diagnostics-lsp-diagnostics)), so the squiggle covers +the text to delete. From a22f5705c88e129c94d6f2311b40165aeab333b9 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 21:59:27 +1000 Subject: [PATCH 07/10] fixes --- .gitignore | 5 + crates/osprey-ast/src/lib.rs | 15 ++ crates/osprey-cli/src/main.rs | 6 +- crates/osprey-cli/src/project.rs | 26 +- crates/osprey-cli/src/warnings.rs | 175 +++++++++++++ crates/osprey-codegen/src/aggregate.rs | 15 +- crates/osprey-codegen/src/builder.rs | 3 +- crates/osprey-codegen/src/curry.rs | 22 +- crates/osprey-codegen/src/expr.rs | 44 +++- crates/osprey-codegen/src/llty.rs | 5 + crates/osprey-codegen/src/lower.rs | 7 +- crates/osprey-codegen/src/stmt.rs | 7 +- crates/osprey-codegen/src/types.rs | 11 +- crates/osprey-lsp/src/diagnostics.rs | 23 +- crates/osprey-project/src/annotation.rs | 6 +- crates/osprey-project/src/span.rs | 4 +- crates/osprey-syntax/src/ml/parser.rs | 85 ++++-- crates/osprey-syntax/src/ml/token.rs | 84 ++++-- crates/osprey-types/src/applications.rs | 145 +++++++++++ crates/osprey-types/src/builtin_docs_lang.rs | 4 +- crates/osprey-types/src/builtins.rs | 21 +- crates/osprey-types/src/check.rs | 150 ++++++++--- crates/osprey-types/src/effect_rows.rs | 94 ++++--- crates/osprey-types/src/env.rs | 5 +- crates/osprey-types/src/expr.rs | 20 +- crates/osprey-types/src/info.rs | 41 ++- crates/osprey-types/src/lib.rs | 1 + crates/osprey-types/src/redundant.rs | 55 ++-- crates/osprey-types/src/redundant_sites.rs | 26 +- crates/osprey-types/src/redundant_tests.rs | 246 +++++++++++++++++- crates/osprey-types/src/ty.rs | 2 +- crates/run_test_corpus.sh | 8 +- docs/messaging.md | 9 + docs/plans/0015-generics-and-variance.md | 113 ++++++++ docs/specs/0004-TypeSystem.md | 49 ++-- docs/specs/0012-Built-InFunctions.md | 21 +- docs/specs/0024-MLFlavorSyntax.md | 49 ++++ docs/specs/0035-StagedEffects.md | 26 ++ tests/MOBILE_UNPORTABLE.txt | 2 + tests/effects/README.md | 18 ++ tests/effects/injection/README.md | 62 +++++ .../injection/storage_injection.test.osp | 218 ++++++++++++++++ .../storage_injection.test.osp.expectedoutput | 5 + .../injection/storage_injection.test.ospml | 210 +++++++++++++++ 44 files changed, 1902 insertions(+), 241 deletions(-) create mode 100644 crates/osprey-cli/src/warnings.rs create mode 100644 crates/osprey-types/src/applications.rs create mode 100644 tests/effects/injection/README.md create mode 100644 tests/effects/injection/storage_injection.test.osp create mode 100644 tests/effects/injection/storage_injection.test.osp.expectedoutput create mode 100644 tests/effects/injection/storage_injection.test.ospml diff --git a/.gitignore b/.gitignore index d36c1751..9439014d 100644 --- a/.gitignore +++ b/.gitignore @@ -141,6 +141,11 @@ benchmarks/cases/**/*.o /tests/regressions/basics/files/test_output.txt /tests/regressions/basics/files/test_stale_reason.txt /tests/regressions/effects/osprey_http_state_levels.db +# The injected disk handler in storage_injection.test.{osp,ospml} writes the +# notebook and its archive. Each flavor owns its own names so the twins cannot +# race when the corpus runs them concurrently from the same directory. +/osprey_storage_injection_*.txt +/tests/effects/injection/osprey_storage_injection_*.txt # Core dumps from a crashed C test binary (a container run leaves them here). core diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs index 863aec3e..c89060ad 100644 --- a/crates/osprey-ast/src/lib.rs +++ b/crates/osprey-ast/src/lib.rs @@ -217,6 +217,21 @@ pub struct TypeExpr { } impl TypeExpr { + /// A module contract supplies a type without adding a written annotation. + /// Line zero is reserved for compiler-generated source metadata. + #[must_use] + pub fn as_contract_annotation(&self) -> Self { + let mut ty = self.clone(); + ty.position = Some(Position { line: 0, column: 0 }); + ty + } + + /// Whether this annotation was supplied by module-signature elaboration. + #[must_use] + pub fn is_from_contract(&self) -> bool { + self.position.is_some_and(|position| position.line == 0) + } + /// A bare named type like `Int` or `Ptr`. pub fn named(name: impl Into) -> Self { TypeExpr { diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index c73a46a4..cceb1ec1 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -30,6 +30,7 @@ mod test_cmd; mod test_coverage; mod test_skips; mod toolchain; +mod warnings; mod wasm; use osprey_syntax::Flavor; @@ -473,10 +474,7 @@ pub(crate) fn report_type_errors(input: &CompilationInput) -> usize { for e in &errors { eprintln!("{}", input.diagnostic(e.position, &e.message)); } - for warning in osprey_types::redundant_annotations(input.program()) { - let text = format!("warning: {}", warning.message); - eprintln!("{}", input.diagnostic(warning.position, &text)); - } + warnings::report(input, &osprey_types::redundant_annotations(input.program())); errors.len() } diff --git a/crates/osprey-cli/src/project.rs b/crates/osprey-cli/src/project.rs index b101f0d1..0bed56c6 100644 --- a/crates/osprey-cli/src/project.rs +++ b/crates/osprey-cli/src/project.rs @@ -128,24 +128,24 @@ impl CompilationInput { &self.debug_path } + /// Resolve a flattened checker position to the physical file it was + /// written in, with that file's own line number. + pub(crate) fn location(&self, position: Position) -> (String, u32, u32) { + if let CompilationUnit::Project(project) = &self.unit { + if let Some((source, line)) = project.source_at_line(position.line) { + return (source.path.display().to_string(), line, position.column); + } + } + (self.display_path.clone(), position.line, position.column) + } + /// Format a flattened checker location using its physical source file. pub(crate) fn diagnostic(&self, position: Option, message: &str) -> String { let Some(position) = position else { return format!("{}: {message}", self.display_path); }; - if let CompilationUnit::Project(project) = &self.unit { - if let Some((source, line)) = project.source_at_line(position.line) { - return format!( - "{}:{line}:{}: {message}", - source.path.display(), - position.column - ); - } - } - format!( - "{}:{}:{}: {message}", - self.display_path, position.line, position.column - ) + let (path, line, column) = self.location(position); + format!("{path}:{line}:{column}: {message}") } /// Render symbols with source-level qualified names where assembly mangled them. diff --git a/crates/osprey-cli/src/warnings.rs b/crates/osprey-cli/src/warnings.rs new file mode 100644 index 00000000..b95b4d33 --- /dev/null +++ b/crates/osprey-cli/src/warnings.rs @@ -0,0 +1,175 @@ +//! Terminal rendering for compiler warnings. +//! +//! A warning is advice, and a hundred of them are only useful if a reader can +//! see the shape of the advice at a glance. Warnings are therefore grouped by +//! the file they were written in, listed under an aligned `line:column` +//! gutter, and closed with the count and the rules that raised them, so the +//! summary answers "how much of this is there, and what turned it on" without +//! scrolling back. +//! +//! Rendering is a pure function over the diagnostics so the exact text is +//! testable; printing is the only side effect. + +use std::collections::{BTreeMap, BTreeSet}; + +use osprey_types::TypeWarning; + +use crate::project::CompilationInput; + +/// One file's warnings: the `line:column` gutter and the message, in order. +type Listing = Vec<(String, String)>; + +/// Print `warnings` to stderr. A clean build prints nothing. +pub(crate) fn report(input: &CompilationInput, warnings: &[TypeWarning]) { + if let Some(text) = render(input, warnings) { + eprintln!("{text}"); + } +} + +/// The whole warning block, or `None` when there is nothing to say. +pub(crate) fn render(input: &CompilationInput, warnings: &[TypeWarning]) -> Option { + if warnings.is_empty() { + return None; + } + let blocks: Vec = group(input, warnings) + .into_iter() + .map(|(file, listing)| block(&file, &listing)) + .collect(); + Some(format!("{}\n{}", blocks.join("\n"), summary(warnings))) +} + +/// One file's heading and its aligned listing. +fn block(file: &str, listing: &Listing) -> String { + let width = listing + .iter() + .map(|(gutter, _)| gutter.len()) + .max() + .unwrap_or_default(); + let lines = listing + .iter() + .map(|(gutter, message)| format!(" {gutter:>width$} warning: {message}")) + .collect::>() + .join("\n"); + format!("\n{file}\n{lines}\n") +} + +/// Group warnings by file, keeping each file's own source order. +fn group(input: &CompilationInput, warnings: &[TypeWarning]) -> BTreeMap { + let mut grouped: BTreeMap = BTreeMap::new(); + for warning in warnings { + let (file, gutter) = locate(input, warning); + grouped + .entry(file) + .or_default() + .push((gutter, warning.message.clone())); + } + grouped +} + +/// A warning's file and `line:column` gutter, falling back to the unit's own +/// label for a warning inference could not anchor to a position. +fn locate(input: &CompilationInput, warning: &TypeWarning) -> (String, String) { + match warning.position { + Some(position) => { + let (file, line, column) = input.location(position); + (file, format!("{line}:{column}")) + } + None => (input.display_path().to_string(), String::from("-")), + } +} + +/// The closing line: how many warnings there are and which rules raised them. +fn summary(warnings: &[TypeWarning]) -> String { + let rules: BTreeSet<&str> = warnings.iter().map(|w| w.rule).collect(); + let plural = if warnings.len() == 1 { "" } else { "s" }; + format!( + "{} warning{plural} ({})", + warnings.len(), + rules.into_iter().collect::>().join(", ") + ) +} + +#[cfg(test)] +mod tests { + use super::render; + use crate::project::CompilationInput; + use osprey_ast::Position; + use osprey_types::{TypeWarning, REDUNDANT_ANNOTATION}; + + /// A single-file unit whose warnings resolve against `main.osp`. + fn unit() -> CompilationInput { + let program = osprey_syntax::parse_program("let answer = 42\n").program; + CompilationInput::script("main.osp", String::new(), program) + } + + fn warning(line: u32, column: u32, message: &str) -> TypeWarning { + TypeWarning { + message: message.to_string(), + position: Some(Position { line, column }), + rule: REDUNDANT_ANNOTATION, + } + } + + #[test] + fn a_clean_program_renders_nothing_at_all() { + assert_eq!(render(&unit(), &[]), None); + } + + #[test] + fn one_warning_renders_its_file_gutter_message_and_singular_summary() { + let raised = [warning(3, 4, "redundant return type annotation on `greet`")]; + assert_eq!( + render(&unit(), &raised), + Some( + "\nmain.osp\n 3:4 warning: redundant return type annotation on `greet`\n\n1 warning (redundant-annotation)" + .to_string() + ) + ); + } + + #[test] + fn gutters_are_right_aligned_so_messages_line_up() { + let raised = [warning(9, 1, "first"), warning(100, 12, "second")]; + assert_eq!( + render(&unit(), &raised), + Some( + "\nmain.osp\n 9:1 warning: first\n 100:12 warning: second\n\n2 warnings (redundant-annotation)" + .to_string() + ) + ); + } + + #[test] + fn a_positionless_warning_still_lists_under_its_unit() { + let raised = [TypeWarning { + message: String::from("nowhere in particular"), + position: None, + rule: REDUNDANT_ANNOTATION, + }]; + assert_eq!( + render(&unit(), &raised), + Some( + "\nmain.osp\n - warning: nowhere in particular\n\n1 warning (redundant-annotation)" + .to_string() + ) + ); + } + + #[test] + fn the_summary_lists_every_rule_that_fired_once_each() { + let raised = [ + warning(1, 0, "a"), + warning(2, 0, "b"), + TypeWarning { + message: String::from("c"), + position: Some(Position { line: 3, column: 0 }), + rule: "some-other-rule", + }, + ]; + let text = render(&unit(), &raised).unwrap_or_default(); + assert!( + text.ends_with("\n3 warnings (redundant-annotation, some-other-rule)"), + "{text}" + ); + } +} diff --git a/crates/osprey-codegen/src/aggregate.rs b/crates/osprey-codegen/src/aggregate.rs index e1e76e16..0734d412 100644 --- a/crates/osprey-codegen/src/aggregate.rs +++ b/crates/osprey-codegen/src/aggregate.rs @@ -347,6 +347,7 @@ pub(crate) fn gen_update( /// load the field. pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> Result { let tv = gen_expr(cg, target)?; + let inferred = tv.inferred_type.as_ref().and_then(|ty| cg.prog.field_type(ty, field)); // Use the statically-known owner (a named record or an anonymous object // literal) when it actually declares `field`; otherwise (a generic accessor // whose parameter infers to a type variable) resolve the field by name across @@ -370,6 +371,7 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> .find_map(|(i, (f, t))| (f == field).then_some((i, *t))) .ok_or_else(|| CodegenError::invalid(format!("`{owner}` has no field `{field}`")))?; + let fty = inferred.as_ref().map_or(fty, crate::types::ltype_of); // A record that crossed a generic boundary — a list element, an inlined // parameter whose type is still a variable — travels in the uniform machine // word, so restore the handle before reading a slot out of it. @@ -383,11 +385,16 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> // A handle field carries its ELEMENT's ABI, not an owner of its own: the // slot holds a runtime id, and `recv`/`await` on it needs the element type // to unbox with ([CONCURRENCY-CHANNEL]). - if let Some(handle) = cg.ctor_field_handle(&owner, field) { - return Ok(handle.restore(Value::new(loaded, fty))); + if let Some(handle) = inferred.as_ref().and_then(|ty| crate::builder::FiberSig::of(&cg.prog, ty)) + .or_else(|| cg.ctor_field_handle(&owner, field)) { + let mut value = handle.restore(Value::new(loaded, fty)); + value.inferred_type = inferred; + return Ok(value); } - let owner = cg.ctor_field_owner(&owner, field); - Ok(Value::new(loaded, fty).with_owner(owner)) + let owner = inferred.as_ref().map_or_else(|| cg.ctor_field_owner(&owner, field), |ty| crate::types::owner_name(&cg.prog, ty)); + let mut value = Value::new(loaded, fty).with_owner(owner); + value.inferred_type = inferred; + Ok(value) } /// Aggregate layouts do not yet carry the shape metadata needed to preserve a diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs index c4581585..69a4ac10 100644 --- a/crates/osprey-codegen/src/builder.rs +++ b/crates/osprey-codegen/src/builder.rs @@ -702,7 +702,8 @@ impl Codegen { /// [TYPE-FN-HIGHER-ORDER]. pub(crate) fn callee_fn_type(&self, expr: &Expr) -> Option { match expr { - Expr::TypeApply { function, .. } => self.callee_fn_type(function), + Expr::TypeApply { function, position, .. } => self.callee_fn_type(function) + .map(|ty| self.prog.application_type(*position, &ty)), Expr::Identifier(name) => self.identifier_fn_type(name), // A call evaluates to its callee's return type — recurse so a chain // peels one arrow per application. diff --git a/crates/osprey-codegen/src/curry.rs b/crates/osprey-codegen/src/curry.rs index 94a13b1c..d96da058 100644 --- a/crates/osprey-codegen/src/curry.rs +++ b/crates/osprey-codegen/src/curry.rs @@ -12,11 +12,17 @@ use crate::builder::Codegen; use crate::error::Result; use crate::expr::gen_expr; use crate::llty::Value; -use osprey_ast::{Expr, NamedArgument}; +use osprey_ast::{Expr, NamedArgument, Position}; /// One application group of a spine: `f(a, b)(c)` has groups `[a, b]`, `[c]`. pub(crate) type ArgGroup<'a> = (&'a [Expr], &'a [NamedArgument]); +struct Spine<'a> { + head: &'a str, + application: Option, + groups: Vec>, +} + /// Lower `function(arguments)` when `function` is itself an application spine /// headed by a generic user function — `None` when it is anything else, so the /// ordinary call paths keep precedence. @@ -26,7 +32,7 @@ pub(crate) fn try_spine( arguments: &[Expr], named: &[NamedArgument], ) -> Result> { - let Some((head, mut groups)) = spine(function) else { + let Some(Spine { head, application, mut groups }) = spine(function) else { return Ok(None); }; if !cg.fn_defs.contains_key(head) { @@ -36,17 +42,21 @@ pub(crate) fn try_spine( let Some((first, rest)) = groups.split_first() else { return Ok(None); }; - crate::genfn::try_inline(cg, head, first.0, first.1, rest) + crate::expr::with_application(cg, application, |cg| crate::genfn::try_inline(cg, head, first.0, first.1, rest)) } /// Flatten an application spine into its head identifier and argument groups, /// outermost group last. `None` when the head is not a bare name. -fn spine(expr: &Expr) -> Option<(&str, Vec>)> { +fn spine(expr: &Expr) -> Option> { let mut groups = Vec::new(); let mut node = expr; + let mut application = None; loop { match node { - Expr::TypeApply { function, .. } => node = function, + Expr::TypeApply { function, position, .. } => { + application = *position; + node = function; + }, Expr::Call { function, arguments, @@ -57,7 +67,7 @@ fn spine(expr: &Expr) -> Option<(&str, Vec>)> { } Expr::Identifier(name) => { groups.reverse(); - return Some((name.as_str(), groups)); + return Some(Spine { head: name, application, groups }); } _ => return None, } diff --git a/crates/osprey-codegen/src/expr.rs b/crates/osprey-codegen/src/expr.rs index a0818360..b37c5fc6 100644 --- a/crates/osprey-codegen/src/expr.rs +++ b/crates/osprey-codegen/src/expr.rs @@ -10,9 +10,28 @@ use crate::error::{CodegenError, Result}; use crate::llty::{LType, Value}; use crate::pattern::gen_match; use crate::runtime::{gen_print, to_string_value}; -use osprey_ast::{Expr, InterpolatedPart, NamedArgument, Parameter, Stmt}; +use osprey_ast::{Expr, InterpolatedPart, NamedArgument, Parameter, Position, Stmt}; pub(crate) fn gen_expr(cg: &mut Codegen, expr: &Expr) -> Result { + let inferred = match expr { + Expr::Integer(_) => Some(osprey_types::Type::con(osprey_types::names::INT, Vec::new())), + Expr::Float(_) => Some(osprey_types::Type::con(osprey_types::names::FLOAT, Vec::new())), + Expr::Bool(_) => Some(osprey_types::Type::con(osprey_types::names::BOOL, Vec::new())), + Expr::Str(_) | Expr::InterpolatedStr(_) => Some(osprey_types::Type::con(osprey_types::names::STRING, Vec::new())), + Expr::Call { function, .. } => cg.callee_fn_type(function).and_then(|ty| match ty { + osprey_types::Type::Fun { ret, .. } => Some(*ret), + _ => None, + }), + Expr::List(_, position) => cg.prog.list_elem_type(*position).cloned().map(|element| osprey_types::Type::con(osprey_types::names::LIST, vec![element])), + Expr::Perform { position, .. } => position.and_then(|p| cg.prog.performs.get(&(p.line, p.column))).map(|site| site.op.ret.clone()), + _ => None, + }; + let mut value = gen_expr_raw(cg, expr)?; + if let Some(ty) = inferred.filter(|ty| !osprey_types::has_type_var(ty)) { value.inferred_type = Some(ty); } + Ok(value) +} + +fn gen_expr_raw(cg: &mut Codegen, expr: &Expr) -> Result { match expr { Expr::Integer(n) => Ok(Value::new(n.to_string(), LType::I64)), Expr::Float(f) => Ok(Value::new(fmt_double(*f), LType::Double)), @@ -801,6 +820,22 @@ const BUILTIN_DISPATCH: [BuiltinDispatch; 8] = [ crate::extern_call::gen, ]; +pub(crate) fn unapplied(mut expression: &Expr) -> &Expr { + while let Expr::TypeApply { function, .. } = expression { expression = function; } + expression +} + +pub(crate) fn with_application(cg: &mut Codegen, position: Option, generate: impl FnOnce(&mut Codegen) -> R) -> R { + let bindings = position.and_then(|p| cg.prog.applications.get(&(p.line, p.column))).cloned(); + let original = bindings.map(|b| { + let specialized = cg.prog.specialized(&b); + std::mem::replace(&mut cg.prog, specialized) + }); + let result = generate(cg); + if let Some(original) = original { cg.prog = original; } + result +} + fn gen_call( cg: &mut Codegen, function: &Expr, @@ -808,12 +843,7 @@ fn gen_call( named: &[NamedArgument], ) -> Result { if let Expr::TypeApply { function, position, .. } = function { - let bindings = position.and_then(|p| cg.prog.applications.get(&(p.line, p.column))).cloned().unwrap_or_default(); - let specialized = cg.prog.specialized(&bindings); - let original = std::mem::replace(&mut cg.prog, specialized); - let result = gen_call(cg, function, arguments, named); - cg.prog = original; - return result; + return with_application(cg, *position, |cg| gen_call(cg, function, arguments, named)); } // A directly-applied lambda (`x |> fn(y) => …`, `(fn(y) => …)(x)`) is // beta-reduced inline. diff --git a/crates/osprey-codegen/src/llty.rs b/crates/osprey-codegen/src/llty.rs index 1a903e6e..bf8b5b2f 100644 --- a/crates/osprey-codegen/src/llty.rs +++ b/crates/osprey-codegen/src/llty.rs @@ -227,6 +227,8 @@ pub struct Value { /// (`Point`, `Shape`, `Result`, …) so field access and `match` can recover /// the heap layout. `None` for scalars and untyped handles. pub(crate) osp_ty: Option, + /// The semantic type survives equal-layout generic record instantiations. + pub(crate) inferred_type: Option, /// When `Some(inner)`, this value is a `Result` carried as a /// pointer to a heap block `{ inner, i8 disc }` (disc 0 = Success). Match, /// `?:`, failure-preserving arithmetic, and Result rendering read this to @@ -264,6 +266,7 @@ impl Value { operand: operand.into(), ty, osp_ty: None, + inferred_type: None, result_inner: None, result_inner_is_placeholder: false, payload_owner: None, @@ -280,6 +283,7 @@ impl Value { operand: operand.into(), ty: LType::Ptr, osp_ty: Some(owner.into()), + inferred_type: None, result_inner: None, result_inner_is_placeholder: false, payload_owner: None, @@ -297,6 +301,7 @@ impl Value { operand: operand.into(), ty: LType::Ptr, osp_ty: Some("Result".to_string()), + inferred_type: None, result_inner: Some(inner), result_inner_is_placeholder: false, payload_owner: None, diff --git a/crates/osprey-codegen/src/lower.rs b/crates/osprey-codegen/src/lower.rs index 08a2ceda..36f929c7 100644 --- a/crates/osprey-codegen/src/lower.rs +++ b/crates/osprey-codegen/src/lower.rs @@ -80,7 +80,9 @@ fn compile_program_with_options(program: &Program, options: CodegenOptions) -> R fn compile_module(program: &Program, options: CodegenOptions, library: bool) -> Result { let options = with_kernel_mode(options)?; - let prog = osprey_types::infer_program(program); + let mut prog = osprey_types::infer_program(program); + let elaborated = prog.elaborate_calls(program); + let program = &elaborated; let mut cg = Codegen::with_options(prog, options); // Seed the coverage denominator from the source, not from what lowering // happens to reach [TESTING-COVERAGE-CODEGEN]. @@ -305,7 +307,8 @@ fn gen_function( let mut params = Vec::new(); for (i, (p, (pty, owner))) in parameters.iter().zip(param_sig.iter()).enumerate() { let reg = crate::llty::param_register(i); - let v = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), owner.clone()); + let mut v = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), owner.clone()); + v.inferred_type = cg.prog.param_types(name).and_then(|types| types.get(i)).cloned(); cg.emit_debug_param(&p.name, &v); cg.bind(p.name.clone(), v); params.push((pty.ty, reg)); diff --git a/crates/osprey-codegen/src/stmt.rs b/crates/osprey-codegen/src/stmt.rs index 28044786..a7a840fd 100644 --- a/crates/osprey-codegen/src/stmt.rs +++ b/crates/osprey-codegen/src/stmt.rs @@ -288,7 +288,10 @@ fn gen_bind(cg: &mut Codegen, name: &str, value: &Expr, position: Option …; f = makeAdder(10)` must // call the new closure, not the old inline body. @@ -362,7 +365,7 @@ fn generic_returned_lambda(cg: &Codegen, value: &Expr) -> Option let Expr::Call { function, .. } = value else { return None; }; - let Expr::Identifier(callee) = &**function else { + let Expr::Identifier(callee) = crate::expr::unapplied(function) else { return None; }; // A CONCRETELY-typed result materializes a real cell on the ordinary path, diff --git a/crates/osprey-codegen/src/types.rs b/crates/osprey-codegen/src/types.rs index 85832910..f3754a5f 100644 --- a/crates/osprey-codegen/src/types.rs +++ b/crates/osprey-codegen/src/types.rs @@ -97,6 +97,11 @@ pub(crate) fn result_payload_owner(prog: &ProgramTypes, ty: &Type) -> Option Option { match ty { + Type::Record { name, fields } if prog.ctors.get(name).is_some_and(|layout| !layout.type_params.is_empty()) => { + let layout = prog.ctors.get(name)?; + let shape: Option> = layout.fields.iter().map(|(field, _)| fields.get(field).map(|ty| ltype_of(ty).as_str())).collect(); + shape.map(|shape| format!("{name}#{}", shape.join(","))) + } Type::Record { name, .. } | Type::Union { name, .. } => Some(name.clone()), Type::Con { name, args } => match name.as_str() { names::INT @@ -149,11 +154,7 @@ pub(crate) fn record_shape(prog: &ProgramTypes, name: &str, args: &[Type]) -> Op if !layout.owner_is_record || layout.type_params.is_empty() { return None; } - let shape: Vec<&str> = layout - .fields - .iter() - .map(|(_, t)| ltype_of(&substituted(t, args)).as_str()) - .collect(); + let shape: Vec<&str> = layout.fields.iter().map(|(_, t)| ltype_of(&substituted(t, args)).as_str()).collect(); Some(format!("{name}#{}", shape.join(","))) } diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs index 599e1b27..4314064b 100644 --- a/crates/osprey-lsp/src/diagnostics.rs +++ b/crates/osprey-lsp/src/diagnostics.rs @@ -110,13 +110,19 @@ fn type_diagnostics( program: &Program, encoding: PositionEncoding, ) -> Vec { - osprey_types::check_program(program) + let mut diagnostics: Vec<_> = osprey_types::check_program(program) .iter() .map(|e| { let pos = e.position.unwrap_or(Position { line: 1, column: 0 }); diagnostic(source, pos, &e.message, "type-error", encoding) }) - .collect() + .collect(); + if diagnostics.is_empty() { + diagnostics.extend(osprey_types::redundant_annotations(program).into_iter().map(|raised| { + warning(source, raised.position.unwrap_or(Position { line: 1, column: 0 }), &raised.message, raised.rule, encoding) + })); + } + diagnostics } /// Single-source assembly for a module-bearing file that no project claims — @@ -194,7 +200,8 @@ fn assembled_type_errors( project: &AssembledProject, encoding: PositionEncoding, ) -> Vec { - osprey_types::check_program(&project.program) + let errors = osprey_types::check_program(&project.program); + let mut diagnostics: Vec<_> = errors .iter() .filter_map(|error| { let position = if let Some(global) = error.position { @@ -217,7 +224,15 @@ fn assembled_type_errors( encoding, )) }) - .collect() + .collect(); + if errors.is_empty() { + diagnostics.extend(osprey_types::redundant_annotations(&project.program).into_iter().filter_map(|raised| { + let global = raised.position?; + let (owner, line) = project.source_at_line(global.line)?; + same_path(&owner.path, file).then(|| warning(source, Position { line, column: global.column }, &raised.message, raised.rule, encoding)) + })); + } + diagnostics } fn project_errors( diff --git a/crates/osprey-project/src/annotation.rs b/crates/osprey-project/src/annotation.rs index 3e02f25a..793679a4 100644 --- a/crates/osprey-project/src/annotation.rs +++ b/crates/osprey-project/src/annotation.rs @@ -23,7 +23,7 @@ impl Resolver<'_> { ) { match (statement, annotation) { (Stmt::Let { ty, .. }, SignatureItem::Value { ty: contract, .. }) if ty.is_none() => { - *ty = Some(contract.clone()); + *ty = Some(contract.as_contract_annotation()); } ( Stmt::Function { @@ -49,11 +49,11 @@ impl Resolver<'_> { } for (parameter, contract) in parameters.iter_mut().zip(contracts) { if parameter.ty.is_none() { - parameter.ty = Some(contract.clone()); + parameter.ty = Some(contract.as_contract_annotation()); } } if return_type.is_none() { - *return_type = Some(contract_return.clone()); + *return_type = Some(contract_return.as_contract_annotation()); } if effects.is_empty() { effects.clone_from(contract_effects); diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs index 440d8ee1..b2f12520 100644 --- a/crates/osprey-project/src/span.rs +++ b/crates/osprey-project/src/span.rs @@ -181,7 +181,9 @@ fn optional_type(ty: &mut Option, offset: u32) { } fn offset_type(ty: &mut TypeExpr, offset: u32) { - shift(&mut ty.position, offset); + if !ty.is_from_contract() { + shift(&mut ty.position, offset); + } for parameter in &mut ty.generic_params { offset_type(parameter, offset); } diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index 0e12deb4..7969eda4 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -42,7 +42,7 @@ use super::cst::{ MlVariant, }; use super::lexer::lex; -use super::token::{TokKind, Token}; +use super::token::{keyword_spelling, TokKind, Token}; use crate::SyntaxError; use osprey_ast::{Multiplicity, Position, Stage, REPLAYABLE_KEYWORD, STATIC_STAGE_KEYWORD}; @@ -640,24 +640,39 @@ impl Parser<'_> { fn operation_markers(&mut self) -> Option<(Option, bool, String)> { let mut multiplicity = None; let mut replayable = false; - let mut word = self.ident()?; + let mut word = self.operation_ident()?; if let Some(declared) = Multiplicity::from_keyword(&word) { if self.at_operation_name() { multiplicity = Some(declared); - word = self.ident()?; + word = self.operation_ident()?; } } if word == REPLAYABLE_KEYWORD && self.at_operation_name() { replayable = true; - word = self.ident()?; + word = self.operation_ident()?; } Some((multiplicity, replayable, word)) } - /// Whether the cursor sits on an identifier — the token that proves the + /// Whether the cursor sits on an operation name — the token that proves the /// word just read was a marker rather than the operation's own name. fn at_operation_name(&self) -> bool { - matches!(self.peek(), TokKind::Ident(_)) + matches!(self.peek(), TokKind::Ident(_)) || keyword_spelling(self.peek()).is_some() + } + + /// An effect operation's name. Operation names are their own namespace, so + /// a word this flavor reserves elsewhere still names an operation here: + /// `send : T => Unit` declares an operation called `send`, exactly as + /// `abort : string => Unit` declares one called `abort`. The position is + /// unambiguous — an `effect` block's indented lines, the name after + /// `perform Effect.`, and a handler arm's head admit nothing but a name. + /// Implements [FLAVOR-ML-EFFECT-OP-NAME]. + fn operation_ident(&mut self) -> Option { + if let Some(spelling) = keyword_spelling(self.peek()) { + self.advance(); + return Some(spelling.to_owned()); + } + self.ident() } /// Consume a `(** … *)` doc token sitting in front of an operation line. @@ -1175,14 +1190,11 @@ impl Parser<'_> { func = self.inline_record(name, type_args); } } - if record_head(&func).is_some() && self.at_angle_open() && self.glued() { + if record_head(&func).is_some() && self.glued() && self.at_type_application() { let args = match self.ty_generic_args(String::new()) { MlType::App { args, .. } => args, _ => Vec::new(), }; - if !self.starts_atom() && !self.at_negative_literal_arg() { - self.error("type arguments require a call argument"); - } func = MlExpr::TypeApply { func: Box::new(func), args, @@ -1312,8 +1324,14 @@ impl Parser<'_> { /// Whether the next token can begin an argument atom. fn starts_atom(&self) -> bool { + self.starts_atom_at(0) + } + + /// Whether the token `j` ahead of the cursor could begin an atom. Lookahead + /// needs this to decide a shape before committing to it. + fn starts_atom_at(&self, j: usize) -> bool { matches!( - self.peek(), + self.peek_at(j), TokKind::Int(_) | TokKind::Float(_) | TokKind::Str(_) @@ -1545,7 +1563,7 @@ impl Parser<'_> { if !self.eat(&TokKind::Dot) { self.error("expected '.' between effect and operation in perform"); } - let operation = self.ident().unwrap_or_default(); + let operation = self.operation_ident().unwrap_or_default(); // `op ()` is a zero-argument performance, not application to unit. if matches!(self.peek(), TokKind::LParen) && matches!(self.peek_at(1), TokKind::RParen) { self.advance(); @@ -1637,7 +1655,7 @@ impl Parser<'_> { /// One `op param* => body` arm of a `handle` expression. pub(super) fn handle_arm(&mut self) -> MlHandleArm { let pos = self.pos(); - let operation = self.ident().unwrap_or_default(); + let operation = self.operation_ident().unwrap_or_default(); let mut params = Vec::new(); while let TokKind::Ident(name) = self.peek() { params.push(name.clone()); @@ -2021,9 +2039,29 @@ impl Parser<'_> { /// followed by an inline record (`Ctor(field = v)`): scan a balanced /// `<…>` of type-shaped tokens, then require the `( Ident =` record /// opener — so a `Ctor < x` comparison never misparses. - fn at_generic_record(&self) -> bool { - if !matches!(self.peek(), TokKind::Op(op) if op == "<") { - return false; + /// Whether a glued `<` opens **call-site type arguments** rather than a + /// comparison. `<` alone cannot decide: `x<3` and `x 5` an application and `x bool { + match self.past_angle_run() { + Some(j) => self.starts_atom_at(j), + None => false, + } + } + + /// Scan a `<…>` run that holds only tokens a TYPE can hold, and answer with + /// the offset just past its closing `>`. `None` means the cursor is not on + /// a `<`, or the run holds something no type can (`x<3`), or it never + /// closes — in every one of those the `<` was an operator, and the caller + /// must not commit to a generic form. Nested runs close with `>>`, which + /// this flavor lexes as two `>` tokens, so counting depth is enough. + fn past_angle_run(&self) -> Option { + if !self.at_angle_open() { + return None; } let mut depth = 0usize; let mut j = 0usize; @@ -2033,9 +2071,7 @@ impl Parser<'_> { TokKind::Op(op) if op == ">" => { depth = depth.saturating_sub(1); if depth == 0 { - return matches!(self.peek_at(j + 1), TokKind::LParen) - && matches!(self.peek_at(j + 2), TokKind::Ident(_)) - && matches!(self.peek_at(j + 3), TokKind::Eq); + return Some(j + 1); } } TokKind::Ident(_) @@ -2043,12 +2079,21 @@ impl Parser<'_> { | TokKind::Arrow | TokKind::LParen | TokKind::RParen => {} - _ => return false, + _ => return None, } j += 1; } } + fn at_generic_record(&self) -> bool { + let Some(j) = self.past_angle_run() else { + return false; + }; + matches!(self.peek_at(j), TokKind::LParen) + && matches!(self.peek_at(j + 1), TokKind::Ident(_)) + && matches!(self.peek_at(j + 2), TokKind::Eq) + } + // --- bodies and helpers ---------------------------------------------- /// The body after `=`/`=>`: an inline expression, or an indented layout diff --git a/crates/osprey-syntax/src/ml/token.rs b/crates/osprey-syntax/src/ml/token.rs index 87eb33fe..d584c35e 100644 --- a/crates/osprey-syntax/src/ml/token.rs +++ b/crates/osprey-syntax/src/ml/token.rs @@ -142,36 +142,64 @@ pub(crate) enum TokKind { Eof, } +/// Every keyword spelling paired with the kind it lexes to. This is the ONE +/// list: [`keyword_or_ident`] reads it forwards and [`keyword_spelling`] reads +/// it backwards, so a keyword cannot be added to one direction only. +const KEYWORDS: &[(&str, TokKind)] = &[ + ("mut", TokKind::KwMut), + ("true", TokKind::KwTrue), + ("false", TokKind::KwFalse), + ("match", TokKind::KwMatch), + ("type", TokKind::KwType), + ("extern", TokKind::KwExtern), + ("spawn", TokKind::KwSpawn), + ("effect", TokKind::KwEffect), + ("perform", TokKind::KwPerform), + ("handle", TokKind::KwHandle), + ("resume", TokKind::KwResume), + ("in", TokKind::KwIn), + ("await", TokKind::KwAwait), + ("yield", TokKind::KwYield), + ("send", TokKind::KwSend), + ("recv", TokKind::KwRecv), + ("select", TokKind::KwSelect), + ("import", TokKind::KwImport), + ("namespace", TokKind::KwNamespace), + ("module", TokKind::KwModule), + ("signature", TokKind::KwSignature), + ("export", TokKind::KwExport), + ("opaque", TokKind::KwOpaque), + ("state", TokKind::KwState), + ("as", TokKind::KwAs), +]; + +/// Spellings held back for a future syntax. They lex to [`TokKind::Reserved`], +/// which already carries its own text, so they stay out of [`KEYWORDS`]. +const RESERVED: &[&str] = &["handler", "do"]; + /// Map a bare identifier spelling to its keyword/reserved kind, or treat it as /// an ordinary identifier. pub(crate) fn keyword_or_ident(text: &str) -> TokKind { - match text { - "mut" => TokKind::KwMut, - "true" => TokKind::KwTrue, - "false" => TokKind::KwFalse, - "match" => TokKind::KwMatch, - "type" => TokKind::KwType, - "extern" => TokKind::KwExtern, - "spawn" => TokKind::KwSpawn, - "effect" => TokKind::KwEffect, - "perform" => TokKind::KwPerform, - "handle" => TokKind::KwHandle, - "resume" => TokKind::KwResume, - "in" => TokKind::KwIn, - "await" => TokKind::KwAwait, - "yield" => TokKind::KwYield, - "send" => TokKind::KwSend, - "recv" => TokKind::KwRecv, - "select" => TokKind::KwSelect, - "import" => TokKind::KwImport, - "namespace" => TokKind::KwNamespace, - "module" => TokKind::KwModule, - "signature" => TokKind::KwSignature, - "export" => TokKind::KwExport, - "opaque" => TokKind::KwOpaque, - "state" => TokKind::KwState, - "as" => TokKind::KwAs, - "handler" | "do" => TokKind::Reserved(text.to_owned()), - _ => TokKind::Ident(text.to_owned()), + if RESERVED.contains(&text) { + return TokKind::Reserved(text.to_owned()); + } + match KEYWORDS.iter().find(|(spelling, _)| *spelling == text) { + Some((_, kind)) => kind.clone(), + None => TokKind::Ident(text.to_owned()), } } + +/// The spelling a keyword token was lexed from — the inverse of +/// [`keyword_or_ident`]. +/// +/// A word reserved for one syntactic position is still an ordinary NAME in a +/// position where only a name can appear. Effect operation names are such a +/// position (`effect Chan { send : T => Unit }`), the same contextual rule +/// [`super::parser::Parser::operation_markers`] already applies to `abort` / +/// `once` / `many`. Implements [FLAVOR-ML-EFFECT-OP-NAME]. +pub(crate) fn keyword_spelling(kind: &TokKind) -> Option<&'static str> { + KEYWORDS + .iter() + .find(|(_, candidate)| candidate == kind) + .map(|(spelling, _)| *spelling) +} diff --git a/crates/osprey-types/src/applications.rs b/crates/osprey-types/src/applications.rs new file mode 100644 index 00000000..f3476451 --- /dev/null +++ b/crates/osprey-types/src/applications.rs @@ -0,0 +1,145 @@ +//! Retain inferred call substitutions across backend AST cloning. +//! +//! Implements [TYPE-GENERICS-APPLY] for implicit and explicit applications. +//! Expression ordinals are local to the unchanged source tree; the backend +//! copy carries them in synthetic application positions outside source lines. + +use crate::ctx::InferCtx; +use crate::info::ProgramTypes; +use crate::ty::{Type, VarId}; +use osprey_ast::{walk_program, AstVisitor}; +use osprey_ast::{Expr, Position, Program}; +use std::collections::HashMap; + +type Bindings = HashMap; + +/// Compose origins through let aliases and generic wrapper parameters. +/// A source variable with competing replacements remains unspecialized. +pub(crate) fn expanded(bindings: &Bindings, origins: &HashMap) -> Bindings { + let mut result = bindings.clone(); + loop { + let mut candidates: HashMap> = HashMap::new(); + for origin in origins.values() { + for (var, ty) in origin { + if result.contains_key(var) { + continue; + } + let replacement = crate::env::subst_vars(ty, &result); + if replacement == *ty { + continue; + } + let _ = candidates + .entry(*var) + .and_modify(|candidate| { + if candidate.as_ref() != Some(&replacement) { + *candidate = None; + } + }) + .or_insert(Some(replacement)); + } + } + let before = result.len(); + result.extend( + candidates + .into_iter() + .filter_map(|(var, ty)| ty.map(|ty| (var, ty))), + ); + if before == result.len() { + return result; + } + } +} + +pub(crate) fn collect( + program: &Program, + sites: &HashMap, + ctx: &mut InferCtx, +) -> HashMap { + struct Collector<'a> { + sites: &'a HashMap, + ctx: &'a mut InferCtx, + index: usize, + calls: HashMap, + } + impl AstVisitor for Collector<'_> { + fn expression(&mut self, expression: &Expr) { + let site = match expression { + Expr::Call { function, .. } => Some(function.as_ref()), + Expr::Pipe { right, .. } => Some(right.as_ref()), + _ => None, + }; + if let Some(bindings) = site + .filter(|e| matches!(e, Expr::Identifier(_) | Expr::Path(_))) + .and_then(|e| self.sites.get(&std::ptr::from_ref(e).addr())) + .filter(|b| !b.is_empty()) + { + let _ = self.calls.insert( + self.index, + bindings + .iter() + .map(|(v, t)| (*v, self.ctx.apply(t))) + .collect(), + ); + } + self.index += 1; + } + } + let mut collector = Collector { + sites, + ctx, + index: 0, + calls: HashMap::new(), + }; + walk_program(program, &mut collector); + let origins: HashMap<_, _> = sites + .iter() + .map(|(site, bindings)| { + ( + *site, + bindings + .iter() + .map(|(var, ty)| (*var, collector.ctx.apply(ty))) + .collect(), + ) + }) + .collect(); + collector + .calls + .into_iter() + .map(|(site, bindings)| (site, expanded(&bindings, &origins))) + .collect() +} + +pub(crate) fn elaborate(program: &Program, types: &mut ProgramTypes) -> Program { + let mut result = program.clone(); + let mut index = 0; + for statement in &mut result.statements { + osprey_ast::mutate::statement_children_mut(statement, &mut |e| { + elaborate_expr(e, &mut index, types) + }); + } + result +} + +fn elaborate_expr(expression: &mut Expr, index: &mut usize, types: &mut ProgramTypes) { + let current = *index; + *index += 1; + osprey_ast::mutate::children_mut(expression, &mut |child| elaborate_expr(child, index, types)); + let Some(bindings) = types.call_bindings.get(¤t).cloned() else { + return; + }; + let Ok(column) = u32::try_from(current) else { + return; + }; + let function = match expression { + Expr::Call { function, .. } => function, + Expr::Pipe { right, .. } => right, + _ => return, + }; + let _ = types.applications.insert((0, column), bindings); + **function = Expr::TypeApply { + function: function.clone(), + type_args: Vec::new(), + position: Some(Position { line: 0, column }), + }; +} diff --git a/crates/osprey-types/src/builtin_docs_lang.rs b/crates/osprey-types/src/builtin_docs_lang.rs index be52614f..c25b829a 100644 --- a/crates/osprey-types/src/builtin_docs_lang.rs +++ b/crates/osprey-types/src/builtin_docs_lang.rs @@ -71,9 +71,9 @@ pub(crate) static CORE: &[BuiltinDoc] = &[ ), builtin_doc!( "intDiv", - "Truncating integer division. Zero returns Error(division by zero); INT64_MIN / -1 returns Error(integer overflow).", + "Returns Result. Truncating integer division; a zero divisor is Error(division by zero) and INT64_MIN / -1 is Error(integer overflow).", ["a" => "The dividend", "b" => "The divisor"], - "fn half(n) -> int = intDiv(n, 2) // half(7) == 3", + "fn half(n) = intDiv(n, 2) ?: 0 // half(7) == 3", ), builtin_doc!( "toFloat", diff --git a/crates/osprey-types/src/builtins.rs b/crates/osprey-types/src/builtins.rs index d238a177..78638006 100644 --- a/crates/osprey-types/src/builtins.rs +++ b/crates/osprey-types/src/builtins.rs @@ -7,7 +7,11 @@ //! runtime's supported alternatives (`print`, `toString`, `length`, //! `isEmpty`); `builtin_constraints` checks their concrete call-site types. //! Result-returning runtime builtins return `Result` — the shape the C -//! runtime actually returns — while arithmetic operators use `MathError`. +//! runtime actually returns — while arithmetic uses `MathError`. The split is +//! by what can fail, not by who implements it: `abs` and `intDiv` are +//! arithmetic and carry `MathError` even though the runtime provides them. +//! `checkedAdd`/`checkedSub`/`checkedMul` keep the generic `Error` channel for +//! compatibility. use crate::env::TypeEnv; use crate::ty::{names, Scheme, Type}; @@ -167,10 +171,17 @@ fn core(e: &mut TypeEnv) { vec![i()], Type::result(i(), Type::prim(names::MATH_ERROR)), ); - // Truncating integer division, divide-by-zero-checked → Result. - // The `/` operator is float-only (Osprey spec); this is its integer sibling. - // Implements [BUILTIN-INTDIV]. - mono(e, "intDiv", vec![i(), i()], res(i())); + // Truncating integer division, divide-by-zero-checked. The `/` operator is + // float-only (Osprey spec); this is its integer sibling, so its faults are + // MATH faults and it carries the same `MathError` channel as `abs` and as + // the operators — not the runtime's generic `Error`. Implements + // [BUILTIN-INTDIV]. + mono( + e, + "intDiv", + vec![i(), i()], + Type::result(i(), Type::prim(names::MATH_ERROR)), + ); // Widening int → float. Total, so it is bare `float` rather than a Result: // every i64 has a nearest double. Implements [BUILTIN-TOFLOAT] and the GPU // surface's explicit element conversion [GPU-CONVERT]. diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 12f1a50d..1714019e 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -335,6 +335,14 @@ impl Checker { /// Pass one: fill the declaration tables and the base environment. fn collect(&mut self, program: &Program, env: &mut TypeEnv) { + self.collect_statements(program.statements.iter(), env); + } + + fn collect_statements<'a>( + &mut self, + statements: impl Iterator + Clone, + env: &mut TypeEnv, + ) { // `env` is exactly the builtin table on entry — snapshot it so // `collect_function` can reject redefinition of a built-in. if self.builtins.is_empty() { @@ -343,7 +351,7 @@ impl Checker { // Register every declared type's variance first, so position // validation sees nested constructors' variance regardless of // declaration order. Implements [TYPE-VARIANCE-DECL]. - for stmt in &program.statements { + for stmt in statements.clone() { if let Stmt::Type { name, type_params, .. } = stmt @@ -354,7 +362,7 @@ impl Checker { ); } } - for stmt in &program.statements { + for stmt in statements { match stmt { Stmt::Type { name, @@ -638,7 +646,11 @@ impl Checker { /// Pass two: infer bodies and run top-level statements. fn check(&mut self, program: &Program, env: &mut TypeEnv) { - for stmt in &program.statements { + self.check_statements(&mut program.statements.iter(), env); + } + + fn check_statements(&mut self, statements: &mut dyn Iterator, env: &mut TypeEnv) { + for stmt in statements { match stmt { Stmt::Function { name, @@ -650,26 +662,23 @@ impl Checker { } => self.check_function(name, parameters, effects, body, env, *position), Stmt::Module { body, .. } => { let mut inner = env.child(); - let prog = Program { - statements: body - .iter() - .map(|item| item.declaration.as_ref().clone()) - .collect(), - }; // Module declarations live in their own lexical scope. Run // both checker passes there: the old implementation only // ran pass two, so module functions were never registered // and their bodies were silently skipped. - self.collect(&prog, &mut inner); - self.check(&prog, &mut inner); + self.collect_statements( + body.iter().map(|item| item.declaration.as_ref()), + &mut inner, + ); + self.check_statements( + &mut body.iter().map(|item| item.declaration.as_ref()), + &mut inner, + ); } Stmt::Namespace { body, .. } => { let mut inner = env.child(); - let prog = Program { - statements: body.clone(), - }; - self.collect(&prog, &mut inner); - self.check(&prog, &mut inner); + self.collect_statements(body.iter(), &mut inner); + self.check_statements(&mut body.iter(), &mut inner); } // `let` / assignment / bare-expr statements infer the same way at // top level and inside a block. @@ -1081,6 +1090,8 @@ pub fn check_program_exports(program: &Program, exports: &[&str]) -> Vec crate::info::ProgramTypes { use crate::info::{CtorLayout, ProgramTypes}; let mut checker = checked_program(program); + let call_bindings = + crate::applications::collect(program, &checker.instantiations, &mut checker.ctx); let functions = checker .fn_sigs @@ -1171,12 +1182,33 @@ pub fn infer_program(program: &Program) -> crate::info::ProgramTypes { lists, performs, handler_ops, - applications: checker.application_tys.iter().map(|(position, bindings)| { - ((position.line, position.column), bindings.iter().map(|(var, ty)| (*var, checker.ctx.apply(ty))).collect()) - }).collect(), - declared_params: checker.fn_typarams.iter().map(|(name, bindings)| { - (name.clone(), bindings.iter().map(|(name, ty)| (name.clone(), checker.ctx.apply(ty))).collect()) - }).collect(), + call_bindings, + applications: checker + .application_tys + .iter() + .map(|(position, bindings)| { + ( + (position.line, position.column), + bindings + .iter() + .map(|(var, ty)| (*var, checker.ctx.apply(ty))) + .collect(), + ) + }) + .collect(), + declared_params: checker + .fn_typarams + .iter() + .map(|(name, bindings)| { + ( + name.clone(), + bindings + .iter() + .map(|(name, ty)| (name.clone(), checker.ctx.apply(ty))) + .collect(), + ) + }) + .collect(), } } @@ -1208,9 +1240,28 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker /// Publish the current inference solution for the closed-program effect proof. fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { - let substitutions: HashMap<_, HashMap<_, _>> = checker.instantiations.iter().map(|(site, bindings)| { - (*site, bindings.iter().map(|(var, ty)| (*var, checker.ctx.apply(ty))).collect()) - }).collect(); + let substitutions: HashMap<_, HashMap<_, _>> = checker + .instantiations + .iter() + .map(|(site, bindings)| { + ( + *site, + bindings + .iter() + .map(|(var, ty)| (*var, checker.ctx.apply(ty))) + .collect(), + ) + }) + .collect(); + let substitutions: HashMap<_, _> = substitutions + .iter() + .map(|(site, bindings)| { + ( + *site, + crate::applications::expanded(bindings, &substitutions), + ) + }) + .collect(); let resolved_arguments: Vec> = checker .perform_tys .clone() @@ -1221,10 +1272,16 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { .collect::>() }) .collect(); - let concrete_arguments = resolved_arguments.iter().cloned().chain(substitutions.values().flat_map(|bindings| { - resolved_arguments.iter().map(move |args| args.iter().map(|arg| crate::env::subst_vars(arg, bindings)).collect()) - })) - .filter(|args| args.iter().all(type_is_resolved)) + let argument_types = resolved_arguments + .iter() + .cloned() + .chain(substitutions.values().flat_map(|bindings| { + resolved_arguments.iter().map(move |args| { + args.iter() + .map(|arg| crate::env::subst_vars(arg, bindings)) + .collect() + }) + })) .map(|args| (args.iter().map(ToString::to_string).collect(), args)) .collect(); let perform_tys = checker.perform_tys.clone(); @@ -1280,16 +1337,39 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { ) })), - concrete_arguments, - instantiations: substitutions.into_iter().map(|(site, bindings)| (site, bindings.into_iter().map(|(var, ty)| (Type::Var(var).to_string(), ty.to_string())).collect())).collect(), - binders: checker.fn_typarams.iter().map(|(name, binders)| (name.clone(), binders.iter().map(|(name, ty)| (name.clone(), checker.ctx.apply(ty).to_string())).collect())).collect(), + argument_types, + instantiations: substitutions + .into_iter() + .map(|(site, bindings)| { + ( + site, + bindings + .into_iter() + .map(|(var, ty)| (Type::Var(var).to_string(), ty.to_string())) + .collect(), + ) + }) + .collect(), + binders: checker + .fn_typarams + .iter() + .map(|(name, binders)| { + ( + name.clone(), + binders + .iter() + .map(|(name, ty)| (name.clone(), checker.ctx.apply(ty).to_string())) + .collect(), + ) + }) + .collect(), ..Default::default() } } /// A handler whose arms leave its binder open learns that binder from the /// operations its body requires, including requirements behind function calls. -/// Only one concrete candidate may refine it; incompatible instantiations stay +/// Only one candidate may refine it; incompatible instantiations stay /// distinct and the ordinary discharge proof rejects the remaining operation. fn refine_handler_arguments( checker: &mut Checker, @@ -1316,7 +1396,9 @@ fn refine_handler_arguments( if arguments.len() != choice.len() { continue; } - let Some(types) = instances.concrete_arguments.get(choice) else { continue; }; + let Some(types) = instances.argument_types.get(choice) else { + continue; + }; for (argument, concrete) in arguments.iter().zip(types) { checker.push_unify(argument, concrete); } diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index 28fd6590..5eb27168 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -25,8 +25,8 @@ pub(crate) struct Instances { /// final fragment overwrite the others. pub(crate) performs: HashMap<(u32, u32), Vec>>, pub(crate) handlers: HashMap<(u32, u32), Vec>, - /// Fully resolved operation arguments available to refine a handler. - pub(crate) concrete_arguments: HashMap, Vec>, + /// Substituted operation arguments available to refine a handler. + pub(crate) argument_types: HashMap, Vec>, /// Candidate instantiations required by each handler's body after calls /// and callbacks have propagated through the closed-program summary. pub(crate) handler_inference: RefCell, @@ -482,7 +482,7 @@ impl Analyzer<'_> { fn function_body(&self, function: &Function<'_>) -> Summary { self.expression( - &function.body, + function.body, &function.scope, &self.scoped_env(&function.parameters), ) @@ -490,7 +490,7 @@ impl Analyzer<'_> { fn function_return(&self, function: &Function<'_>) -> Option { let mut env = self.scoped_env(&function.parameters); - self.returned_value(&function.body, &function.scope, &mut env) + self.returned_value(function.body, &function.scope, &mut env) } fn returned_value( @@ -660,7 +660,7 @@ impl Analyzer<'_> { if let Some(position) = position { let candidates = body_summary.required.iter().filter(|requirement| { requirement.effect == *effect && handled.contains(&requirement.operation) - && self.instances.concrete_arguments.contains_key(&requirement.arguments) + && self.instances.argument_types.contains_key(&requirement.arguments) }).map(|requirement| requirement.arguments.clone()); self.instances.handler_inference.borrow_mut() .entry((position.line, position.column)).or_default().extend(candidates); @@ -999,7 +999,11 @@ impl Analyzer<'_> { fn value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { let mut value = self.raw_value(expression, scope, env)?; - if let Some(bindings) = self.instances.instantiations.get(&std::ptr::from_ref(expression).addr()) { + if let Some(bindings) = self + .instances + .instantiations + .get(&std::ptr::from_ref(expression).addr()) + { specialize_value(&mut value, bindings); } Some(value) @@ -1925,7 +1929,12 @@ fn merge_callable(slot: &mut Option, incoming: Callable) { }))); } -fn bind_pattern(pattern: &Pattern, value: Option<&Value>, index: &Index<'_>, env: &mut CallableEnv) { +fn bind_pattern( + pattern: &Pattern, + value: Option<&Value>, + index: &Index<'_>, + env: &mut CallableEnv, +) { match pattern { Pattern::Binding(name) | Pattern::TypeAnnotated { name, .. } => { let _ = env.shadowed.insert(name.clone()); @@ -2140,35 +2149,58 @@ fn specialize_argument(argument: &str, bindings: &HashMap) -> St } else { result.push_str(bindings.get(&token).unwrap_or(&token)); token.clear(); - if character != '\0' { result.push(character); } + if character != '\0' { + result.push(character); + } } } result } fn specialize_requirements(requirements: &mut Requirements, bindings: &HashMap) { - *requirements = std::mem::take(requirements).into_iter().map(|mut requirement| { - requirement.arguments = requirement.arguments.iter().map(|arg| specialize_argument(arg, bindings)).collect(); - requirement - }).collect(); + *requirements = std::mem::take(requirements) + .into_iter() + .map(|mut requirement| { + requirement.arguments = requirement + .arguments + .iter() + .map(|arg| specialize_argument(arg, bindings)) + .collect(); + requirement + }) + .collect(); } fn specialize_summary(summary: &mut Summary, bindings: &HashMap) { specialize_requirements(&mut summary.required, bindings); - summary.parameter_uses = std::mem::take(&mut summary.parameter_uses).into_iter().map(|mut use_| { - specialize_requirements(&mut use_.excluded, bindings); - use_ - }).collect(); + summary.parameter_uses = std::mem::take(&mut summary.parameter_uses) + .into_iter() + .map(|mut use_| { + specialize_requirements(&mut use_.excluded, bindings); + use_ + }) + .collect(); } fn specialize_value(value: &mut Value, bindings: &HashMap) { specialize_summary(&mut value.deferred, bindings); if let Some(Callable::Known(known)) = &mut value.callable { specialize_summary(&mut known.summary, bindings); - if let Some(returned) = &mut known.returned { specialize_value(returned, bindings); } + if let Some(returned) = &mut known.returned { + specialize_value(returned, bindings); + } } - for nested in value.fields.values_mut() { specialize_value(nested, bindings); } - for nested in [value.element.as_mut(), value.result_payload.as_mut(), value.fiber_payload.as_mut()].into_iter().flatten() { + for nested in value.fields.values_mut() { + specialize_value(nested, bindings); + } + for nested in [ + value.element.as_mut(), + value.result_payload.as_mut(), + value.fiber_payload.as_mut(), + ] + .into_iter() + .flatten() + { specialize_value(nested, bindings); } } @@ -2268,14 +2300,18 @@ pub(crate) fn check(program: &Program, instances: &Instances, exports: &[&str]) .filter(|requirement| { !function.declared_effects.iter().any(|declared| { declared.name == requirement.effect - && declared - .arguments - .as_ref() - .is_none_or(|arguments| { - let bindings = instances.binders.get(&function.name); - arguments.iter().map(|arg| bindings.map_or_else(|| arg.clone(), |b| specialize_argument(arg, b))) - .eq(requirement.arguments.iter().cloned()) - }) + && declared.arguments.as_ref().is_none_or(|arguments| { + let bindings = instances.binders.get(&function.name); + arguments + .iter() + .map(|arg| { + bindings.map_or_else( + || arg.clone(), + |b| specialize_argument(arg, b), + ) + }) + .eq(requirement.arguments.iter().cloned()) + }) }) }) .map(requirement_name) @@ -2294,7 +2330,7 @@ pub(crate) fn check(program: &Program, instances: &Instances, exports: &[&str]) validate_handler_arms( &analyzer, &axis, - &function.body, + function.body, &function.scope, &analyzer.scoped_env(&function.parameters), &mut errors, @@ -2601,7 +2637,7 @@ fn reachable_bodies<'a>( { if visited.insert(id) { if let Some(function) = index.functions.get(id) { - regions.push((&function.body, &function.scope)); + regions.push((function.body, &function.scope)); } } } diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index fc792c67..7162b12b 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -88,7 +88,10 @@ impl TypeEnv { .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))) .collect(); Some(AppliedSignature { - ty: subst_vars(&scheme.ty, &map), obligations, params, bindings: map, + ty: subst_vars(&scheme.ty, &map), + obligations, + params, + bindings: map, }) } diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index fc3fbf4e..0501a3ea 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -550,7 +550,9 @@ impl Checker { // ([`crate::ty::Scheme::obligations`]). self.builtin_uses.extend(applied.obligations); if let Some(site) = site { - let _ = self.instantiations.insert(std::ptr::from_ref(site).addr(), applied.bindings); + let _ = self + .instantiations + .insert(std::ptr::from_ref(site).addr(), applied.bindings); } return applied.ty; } @@ -578,7 +580,10 @@ impl Checker { type_args, position, } => self.infer_type_application(function, type_args, *position, env), - Expr::Identifier(name) => (Some(name.clone()), self.lookup_ident_at(name, env, Some(function))), + Expr::Identifier(name) => ( + Some(name.clone()), + self.lookup_ident_at(name, env, Some(function)), + ), Expr::Path(path) => { let name = path.to_string(); let ty = self.lookup_ident_at(&name, env, Some(function)); @@ -608,12 +613,19 @@ impl Checker { let Some(applied) = env.applied(&mut self.ctx, &name) else { return (Some(name.clone()), self.lookup_ident(&name, env)); }; - let crate::env::AppliedSignature { ty, obligations, params, bindings } = applied; + let crate::env::AppliedSignature { + ty, + obligations, + params, + bindings, + } = applied; self.builtin_uses.extend(obligations); if let Some(position) = position { self.application_tys.push((position, bindings.clone())); } - let _ = self.instantiations.insert(std::ptr::from_ref(function).addr(), bindings); + let _ = self + .instantiations + .insert(std::ptr::from_ref(function).addr(), bindings); if params.len() == type_args.len() { let binder = self.current_fn_typarams.clone(); for (param, arg) in params.iter().zip(type_args) { diff --git a/crates/osprey-types/src/info.rs b/crates/osprey-types/src/info.rs index 67d8e772..d735f543 100644 --- a/crates/osprey-types/src/info.rs +++ b/crates/osprey-types/src/info.rs @@ -75,6 +75,7 @@ pub struct ProgramTypes { pub applications: HashMap<(u32, u32), HashMap>, /// Binder identity is part of the contract even when its spelling is omitted. pub(crate) declared_params: HashMap>, + pub(crate) call_bindings: HashMap>, } /// One `perform` site's resolved instantiation. @@ -96,6 +97,38 @@ pub struct HandlerSite { } impl ProgramTypes { + /// Instantiate a record field against the actual generic type arguments. + #[must_use] + pub fn field_type(&self, record: &Type, field: &str) -> Option { + match record { + Type::Record { fields, .. } => fields.get(field).cloned(), + Type::Con { name, args } => { + let layout = self.ctors.get(name)?; + let (_, ty) = layout.fields.iter().find(|(name, _)| name == field)?; + let bindings = args.iter().enumerate().filter_map(|(i, ty)| u32::try_from(i).ok().map(|i| (i, ty.clone()))).collect(); + Some(crate::env::subst_vars(ty, &bindings)) + } + _ => None, + } + } + + /// Resolve a named callee's signature against this application's binders. + #[must_use] + pub fn application_type(&self, position: Option, ty: &Type) -> Type { + position + .and_then(|p| self.applications.get(&(p.line, p.column))) + .map_or_else( + || ty.clone(), + |bindings| crate::env::subst_vars(ty, bindings), + ) + } + + /// Attach inferred applications to a backend copy of the source program. + /// The source AST and its diagnostic positions remain unchanged. + pub fn elaborate_calls(&mut self, program: &osprey_ast::Program) -> osprey_ast::Program { + crate::applications::elaborate(program, self) + } + /// Specialize inferred body metadata with one call's type substitution. /// Constructor and effect declarations retain their shared erased ABI. #[must_use] @@ -121,8 +154,12 @@ impl ProgramTypes { substitute(&mut op.ret); } } - for args in result.applications.values_mut() { args.values_mut().for_each(&substitute); } - for args in result.declared_params.values_mut() { args.values_mut().for_each(&substitute); } + for args in result.applications.values_mut() { + args.values_mut().for_each(&substitute); + } + for args in result.declared_params.values_mut() { + args.values_mut().for_each(&substitute); + } result } diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index 9e41039d..79414739 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -13,6 +13,7 @@ //! [`redundant_annotations`] returns the [`TypeWarning`]s for annotations the //! inferrer would have derived on its own ([TYPE-ANNOTATION-REDUNDANT]). +mod applications; mod builtin_constraints; mod builtin_docs; mod builtin_docs_lang; diff --git a/crates/osprey-types/src/redundant.rs b/crates/osprey-types/src/redundant.rs index 5b53789e..cfcc50d9 100644 --- a/crates/osprey-types/src/redundant.rs +++ b/crates/osprey-types/src/redundant.rs @@ -56,28 +56,22 @@ pub fn redundant_annotations(program: &Program) -> Vec { return Vec::new(); } let baseline = published(program); - if preserves(&baseline, &erase(program, &mut |_| false)) { - return written.iter().map(warn).collect(); - } - attribute(program, &baseline, &written) -} - -/// Test each annotation on its own, once erasing all of them at once has been -/// ruled out. One of them is load-bearing; only re-solving with exactly one -/// removed says which. -fn attribute(program: &Program, baseline: &Published, written: &[Site]) -> Vec { written .iter() .enumerate() - .filter(|(index, _)| preserves(baseline, &erase(program, &mut |site| site != *index))) + .filter(|(index, _)| preserves(program, &baseline, *index)) .map(|(_, site)| warn(site)) .collect() } -/// Whether `candidate` — `program` minus some annotations — still typechecks -/// and still publishes the same types, up to renaming of type variables. -fn preserves(baseline: &Published, candidate: &Program) -> bool { - check_program(candidate).is_empty() && same_types(baseline, &published(candidate)) +/// Whether erasing this annotation leaves `program` typechecking +/// and publishing the same types, up to renaming of type variables. +/// +/// The published types are compared first because they are what usually +/// differs, and re-checking is a second full solve this can then skip. +fn preserves(program: &Program, baseline: &Published, index: usize) -> bool { + let candidate = erase(program, &mut |site| site != index); + same_types(baseline, &published(&candidate)) && check_program(&candidate).is_empty() } /// Everything the inferrer resolved, labelled so two runs compare entry by @@ -91,11 +85,32 @@ fn published(program: &Program) -> Published { }; (format!("fn {name}"), signature) }); - functions + let mut published: Published = functions .chain(sited("let", &types.lets)) .chain(sited("lambda", &types.lambdas)) .chain(sited("list", &types.lists)) - .collect() + .collect(); + for (function, binders) in &types.declared_params { + for (name, ty) in binders { + let _ = published.insert(format!("binder {function} {name}"), ty.clone()); + } + } + for (position, site) in &types.performs { + publish_operation(&mut published, &format!("perform {position:?}"), &site.op, &site.effect_args); + } + for (position, site) in &types.handler_ops { + for (operation, op) in &site.ops { + publish_operation(&mut published, &format!("handler {position:?} {operation}"), op, &site.effect_args); + } + } + published +} + +fn publish_operation(published: &mut Published, label: &str, operation: &crate::info::OpType, arguments: &[Type]) { + let _ = published.insert(label.to_owned(), Type::fun(operation.params.clone(), operation.ret.clone())); + for (index, argument) in arguments.iter().enumerate() { + let _ = published.insert(format!("{label} argument {index}"), argument.clone()); + } } /// Label one position-keyed table so its entries join the same flat map. @@ -115,7 +130,9 @@ fn sited<'a>( fn warn(site: &Site) -> TypeWarning { let written = &site.written; let message = match &site.slot { - Slot::Param { owner, parameter } => format!( + Slot::Param { + owner, parameter, .. + } => format!( "redundant type annotation on parameter `{parameter}` of `{owner}`: inference derives `{written}` without it" ), Slot::Return { owner } => format!( @@ -126,7 +143,7 @@ fn warn(site: &Site) -> TypeWarning { ), }; TypeWarning { - message, + message: osprey_ast::symbol::demangle_message(&message).into_owned(), position: site.position, rule: REDUNDANT_ANNOTATION, } diff --git a/crates/osprey-types/src/redundant_sites.rs b/crates/osprey-types/src/redundant_sites.rs index 68903849..edf28d3f 100644 --- a/crates/osprey-types/src/redundant_sites.rs +++ b/crates/osprey-types/src/redundant_sites.rs @@ -22,6 +22,9 @@ pub(crate) enum Slot { owner: String, /// The annotated parameter's name. parameter: String, + /// Its position in the parameter list, which is how a signature — that + /// names types and not parameters — addresses it. + index: usize, }, /// A function's or lambda's declared return type. Return { @@ -99,9 +102,13 @@ fn render(annotation: &TypeExpr) -> String { type_expr_to_type(annotation, &HashMap::new()).to_string() } -/// Hand every annotation slot in `program` to `visit`, in pre-order. +/// Visit written annotations, retaining the types supplied by module contracts. fn walk(program: &mut Program, visit: Visit<'_>) { - walk_statements(&mut program.statements, visit); + walk_statements(&mut program.statements, &mut |slot, position, annotation| { + if !annotation.as_ref().is_some_and(TypeExpr::is_from_contract) { + visit(slot, position, annotation); + } + }); } /// Walk a statement sequence — a program body, a namespace, or a block. @@ -137,7 +144,9 @@ fn walk_statement(statement: &mut Stmt, visit: Visit<'_>) { } => visit(Slot::Binding { name: name.clone() }, *position, ty), _ => {} } - statement_children_mut(statement, &mut |expression| walk_expr(expression, &mut *visit)); + statement_children_mut(statement, &mut |expression| { + walk_expr(expression, &mut *visit); + }); } /// Walk the annotation slots reachable through an expression. @@ -152,7 +161,13 @@ fn walk_expr(expression: &mut Expr, visit: Visit<'_>) { .. } = expression { - walk_signature(LAMBDA_OWNER, parameters, return_type, *position, &mut *visit); + walk_signature( + LAMBDA_OWNER, + parameters, + return_type, + *position, + &mut *visit, + ); } if let Expr::Block { statements, value } = expression { walk_statements(statements, &mut *visit); @@ -172,10 +187,11 @@ fn walk_signature( position: Option, visit: Visit<'_>, ) { - for parameter in parameters { + for (index, parameter) in parameters.iter_mut().enumerate() { let slot = Slot::Param { owner: owner.to_string(), parameter: parameter.name.clone(), + index, }; visit(slot, position, &mut parameter.ty); } diff --git a/crates/osprey-types/src/redundant_tests.rs b/crates/osprey-types/src/redundant_tests.rs index 35fc8e7e..68322713 100644 --- a/crates/osprey-types/src/redundant_tests.rs +++ b/crates/osprey-types/src/redundant_tests.rs @@ -6,6 +6,8 @@ //! regression even when it still contains the word "redundant". use crate::redundant::{redundant_annotations, TypeWarning, REDUNDANT_ANNOTATION}; +use std::fmt::Write as _; + use osprey_ast::Position; use osprey_syntax::{parse_program_with_flavor, Flavor}; @@ -147,36 +149,42 @@ fn a_redundant_generic_signature_is_reported_with_its_binder() { fn a_result_returning_annotation_that_matches_inference_is_still_redundant() { reports( Flavor::Default, - "fn half(n: int) -> Result = intDiv(n, 2)\n", + "fn half(n: int) -> Result = intDiv(n, 2)\n", &[ "redundant type annotation on parameter `n` of `half`: inference derives `int` without it", - "redundant return type annotation on `half`: inference derives `Result` without it", + "redundant return type annotation on `half`: inference derives `Result` without it", ], ); } #[test] -fn a_return_annotation_that_narrows_the_error_type_is_kept() { - // `intDiv` yields `Result`; the annotation names a different - // error type, so it is doing work and erasing it changes the signature. +fn a_return_annotation_naming_the_wrong_error_type_is_a_type_error_not_a_warning() { + // `intDiv` yields `Result`. Naming `Error` instead is a + // mismatch the checker rejects, and a rejected program raises no warnings. silent( Flavor::Default, - "fn half(n: int) -> Result = intDiv(n, 2)\n", + "fn half(n: int) -> Result = intDiv(n, 2)\n", ); } #[test] fn ml_and_default_spellings_of_one_signature_report_identically() { let default = messages(Flavor::Default, GREET); - let ml = messages(Flavor::Ml, "greet : string -> string\ngreet name = \"hi \" + name\n"); + let ml = messages( + Flavor::Ml, + "greet : string -> string\ngreet name = \"hi \" + name\n", + ); assert_eq!(default, ml, "flavors disagreed about the same signature"); assert_eq!(ml.len(), 2, "{ml:?}"); } #[test] fn an_ml_module_body_repeating_its_signature_is_still_redundant() { - // The `signature` block is the module's contract and is never reported; - // the body's copy of the same type is judged like any other function. + // The `signature` block is the module's contract and is never reported. + // A member that WRITES the same type again is judged like any other + // function: signature elaboration marks the types it supplies + // ([MODULES-SIGNATURE]), so a written duplicate is distinguishable from + // the copy the compiler pushed onto an unannotated member. reports( Flavor::Ml, "signature Api\n shout : string -> string\n\nmodule M : Api\n shout : string -> string\n shout s = s + \"!\"\n", @@ -187,6 +195,20 @@ fn an_ml_module_body_repeating_its_signature_is_still_redundant() { ); } +#[test] +fn a_module_member_annotation_that_is_not_its_contract_is_still_reported() { + // The carve-out is exactly the contract, not the whole module. A private + // helper the signature never mentions is judged like any other function. + reports( + Flavor::Ml, + "signature Api\n shout : string -> string\n\nmodule M : Api\n louder : string -> string\n louder s = s + \"!!\"\n shout s = louder s\n", + &[ + "redundant type annotation on parameter `s` of `louder`: inference derives `string` without it", + "redundant return type annotation on `louder`: inference derives `string` without it", + ], + ); +} + #[test] fn a_signature_block_alone_reports_nothing() { silent( @@ -221,3 +243,209 @@ fn a_nested_block_binding_is_reached() { ); } +#[test] +fn only_the_redundant_parameter_of_a_pair_is_reported() { + // `label` is pinned by `+`; `count` only by `toString`, which takes any, + // so its annotation is the thing keeping the signature concrete. + reports( + Flavor::Default, + "fn tag(label: string, count: int) -> string = label + toString(count)\n", + &[ + "redundant type annotation on parameter `label` of `tag`: inference derives `string` without it", + "redundant return type annotation on `tag`: inference derives `string` without it", + ], + ); +} + +#[test] +fn a_nominal_record_parameter_annotation_is_kept_but_its_return_is_not() { + // Erasing `p: Point` leaves a structural row that only needs an `x`, which + // is a MORE GENERAL signature than the one written — so the parameter + // annotation is doing work. The return type is derived either way. + reports( + Flavor::Default, + "type Point = { x: int, y: int }\nfn px(p: Point) -> int = p.x\nlet v = px(Point { x: 1, y: 2 })\n", + &["redundant return type annotation on `px`: inference derives `int` without it"], + ); +} + +#[test] +fn a_union_typed_signature_is_reported_with_its_union_name() { + reports( + Flavor::Default, + "type Color = Red | Green | Blue\nfn name(c: Color) -> string = match c {\n Red => \"red\"\n Green => \"green\"\n Blue => \"blue\"\n}\nlet n = name(Red)\n", + &[ + "redundant type annotation on parameter `c` of `name`: inference derives `Color` without it", + "redundant return type annotation on `name`: inference derives `string` without it", + ], + ); +} + +#[test] +fn a_higher_order_parameter_annotation_is_judged_like_any_other() { + let raised = messages( + Flavor::Default, + "fn twice(f: (int) -> int, x: int) -> int = f(f(x))\nfn inc(n: int) -> int = (n + 1) ?: 0\nlet r = twice(inc, 1)\n", + ); + assert!( + raised.contains( + &"redundant type annotation on parameter `x` of `twice`: inference derives `int` without it" + .to_string() + ), + "{raised:?}" + ); +} + +#[test] +fn a_mutable_binding_annotation_is_reported_like_an_immutable_one() { + reports( + Flavor::Default, + "effect State { set: fn(int) -> Unit }\nfn main() -> Unit = {\n mut cell: int = 0\n handle State\n set value => { cell = value }\n in { perform State.set(1) }\n}\n", + &[ + "redundant return type annotation on `main`: inference derives `Unit` without it", + "redundant type annotation on `cell`: inference derives `int` without it", + ], + ); +} + +#[test] +fn an_ml_lambda_parameter_is_reported_against_the_lambda() { + reports( + Flavor::Ml, + "exclaim = \\(s: string) => s + \"!\"\nr = exclaim \"hi\"\n", + &["redundant type annotation on parameter `s` of ``: inference derives `string` without it"], + ); +} + +#[test] +fn a_namespaced_function_is_reported_by_its_source_name_not_its_symbol() { + reports( + Flavor::Ml, + "namespace tax\n\nrate : string -> string\nrate band = band + \"%\"\n", + &[ + "redundant type annotation on parameter `band` of `rate`: inference derives `string` without it", + "redundant return type annotation on `rate`: inference derives `string` without it", + ], + ); +} + +#[test] +fn every_message_names_a_type_and_never_leaks_a_type_variable() { + // `t0`-style inference variables are internal. A warning that printed one + // would be telling the reader to write a type they cannot spell. + let raised = messages(Flavor::Default, GREET); + assert!(!raised.is_empty()); + for message in &raised { + assert!( + message.starts_with("redundant "), + "message does not open with the rule: {message}" + ); + assert!( + message.ends_with(" without it"), + "message does not close with the fix: {message}" + ); + assert!( + !message.contains("`t0`") && !message.contains("`t1`"), + "message leaked an inference variable: {message}" + ); + } +} + +#[test] +fn an_annotation_free_corpus_is_completely_silent() { + silent( + Flavor::Default, + "type Point = { x: int, y: int }\n\ + fn px(p) = p.x\n\ + fn shout(s) = s + \"!\"\n\ + let p = Point { x: 1, y: 2 }\n\ + let out = shout(toString(px(p)))\n", + ); +} + +/// Eight redundantly annotated functions around one whose parameter annotation +/// is doing real work — erasing `p: Point` would widen it to a structural row. +/// This is the shape the group-narrowing search has to get right. +fn mixed_corpus() -> String { + let redundant = (0..8).fold(String::new(), |mut out, i| { + let _ = writeln!(out, "fn f{i}(s: string) -> string = s + \"{i}\""); + out + }); + format!( + "type Point = {{ x: int, y: int }}\n\ + {redundant}\ + fn keeper(p: Point) -> int = p.x\n\ + let v = keeper(Point {{ x: 1, y: 2 }})\n" + ) +} + +#[test] +fn narrowing_does_not_lose_warnings_around_a_load_bearing_annotation() { + // Erasing everything at once fails because of `keeper`, so the search + // splits. Every redundant annotation must still be reported, and + // `keeper`'s load-bearing parameter must not be. + let raised = messages(Flavor::Default, &mixed_corpus()); + assert_eq!(raised.len(), 17, "{raised:?}"); + for index in 0..8 { + assert!( + raised.contains(&format!( + "redundant type annotation on parameter `s` of `f{index}`: inference derives `string` without it" + )), + "lost the parameter of f{index}: {raised:?}" + ); + assert!( + raised.contains(&format!( + "redundant return type annotation on `f{index}`: inference derives `string` without it" + )), + "lost the return type of f{index}: {raised:?}" + ); + } + assert!( + raised.contains( + &"redundant return type annotation on `keeper`: inference derives `int` without it" + .to_string() + ), + "{raised:?}" + ); + assert!( + !raised + .iter() + .any(|m| m.contains("parameter `p` of `keeper`")), + "reported a load-bearing parameter: {raised:?}" + ); +} + +#[test] +fn narrowing_reports_in_source_order_regardless_of_how_it_searched() { + // The search halves the annotation list and so visits it out of order. + // What comes back must still read down the file. + let raised = warnings(Flavor::Default, &mixed_corpus()); + let lines: Vec = raised + .iter() + .filter_map(|w| w.position.map(|p| p.line)) + .collect(); + let mut sorted = lines.clone(); + sorted.sort_unstable(); + assert_eq!(lines, sorted, "warnings came out of order: {raised:?}"); + assert_eq!(lines.len(), raised.len(), "a warning lost its position"); +} + +#[test] +fn the_same_program_reports_the_same_warnings_every_run() { + let source = mixed_corpus(); + let first = messages(Flavor::Default, &source); + let second = messages(Flavor::Default, &source); + assert_eq!(first, second, "detection is not deterministic"); +} + +#[test] +fn an_effect_operation_signature_is_never_reported() { + // An `effect` declares its operations' types; there is no body to infer + // them from, so they are declarations and not constraints. + silent( + Flavor::Default, + "effect Log { line: fn(string) -> Unit }\n\ + fn main() = handle Log\n line message => {}\nin { perform Log.line(\"hi\") }\n", + ); +} + diff --git a/crates/osprey-types/src/ty.rs b/crates/osprey-types/src/ty.rs index 07498469..83f187d0 100644 --- a/crates/osprey-types/src/ty.rs +++ b/crates/osprey-types/src/ty.rs @@ -125,7 +125,7 @@ macro_rules! applied_types { impl Type { /// A constructor application, e.g. `Type::con("List", vec![Type::int()])`. - pub(crate) fn con(name: impl Into, args: Vec) -> Type { + pub fn con(name: impl Into, args: Vec) -> Type { Type::Con { name: name.into(), args, diff --git a/crates/run_test_corpus.sh b/crates/run_test_corpus.sh index 51cb5497..2395099c 100644 --- a/crates/run_test_corpus.sh +++ b/crates/run_test_corpus.sh @@ -68,18 +68,18 @@ esac # Silence is not success — if coverage ever drops below this floor the harness # FAILS rather than quietly checking less than it used to. # -# Natively all 209 programs are covered by golden files, most shared by a +# Natively all 211 programs are covered by golden files, most shared by a # Default/ML flavor pair. On wasm32 the programs blocked on a capability WASI # does not have are skipped — each named in tests/WASM_UNPORTABLE.txt, and a # resumable one named by the OPERATION it cannot suspend [MULTI-WASM] — leaving -# 144. On the mobile C ABI targets the same accounting leaves 130: the rest are +# 146. On the mobile C ABI targets the same accounting leaves 130: the rest are # rejected for a missing capability or for a boundary the scalar C ABI cannot # express, each pinned in tests/MOBILE_UNPORTABLE.txt. # Ratchet UP as goldens are added; never lower it to turn a red build green. case $TARGET in - wasm32) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-144} ;; + wasm32) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-146} ;; ios-sim|android*) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-130} ;; - *) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-209} ;; + *) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-211} ;; esac # [GPU-KERNEL-EXTRACT] differential. The extracted-kernel lowering and the diff --git a/docs/messaging.md b/docs/messaging.md index ad546d4a..edec3e0c 100644 --- a/docs/messaging.md +++ b/docs/messaging.md @@ -234,6 +234,15 @@ These constraints materially affect how the language must be described: answered twice stops the program when it runs rather than when it is written. Describe it only as specified behaviour, on the same footing as the other normative targets, and never as something a developer can use now. +- Integer arithmetic returns a `Result`, not a plain `int`. `+`, `-`, `*`, `abs` + and `intDiv` all carry a `MathError` channel that the caller must discharge, + usually with `?:`. That is a real cost to describe honestly: a `?: 0` on an + overflowing expression fabricates a value and the program exits successfully + with a wrong answer ([#230](https://github.com/Nimblesite/osprey/issues/230)). + [Spec 0037](specs/0037-ArithmeticEffects.md) specifies the replacement — plain + `int` with faults dispatched to an `Arith` handler — as a normative target; + **none of it is implemented**. Describe today's arithmetic as checked and + explicit, and the effect form only as specified behaviour. - Tail-call optimisation is not implemented. - Multi-file project modules and cross-flavor imports are implemented. A package manager remains roadmap work; describe further module or generic features according to their individual implementation status. - GPU computation is a typed language surface with a host execution backend: diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index 04fd6291..67a6ab4e 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -297,3 +297,116 @@ Remaining: `generic_effects_tests.rs` ([EFFECTS-GENERIC-*], plus the `handle … do` spelling spec 0017 writes and the language does not accept — [plan 0027](0027-arithmetic-effects.md) phase 0 owns that rename). + +## Frozen-test conflicts (2026-09-09, second sweep) + +The assertion sweep above was then frozen: no agent may edit, flip or reformat +any test in this tree, so the following are recorded rather than repaired. Each +names the side that is **right**, so whoever lifts the freeze knows which half +to change. Rulings are OspreyAstra1's. + +1. **The compiler is right; the test is wrong — HM generalization.** + `fn empty() -> List = []` then `let held = empty()` and + `length(held)` compiles and prints `0`, and so does a bare `let xs = []`. + An unconstrained binder at an immutable `let` generalizes; nothing observes + `T`'s identity, so there is nothing to reject. Written type arguments *pin* + an instantiation, they are never *required*. + `generics_apply_tests.rs::the_unpinnable_binder_is_the_control_for_that_case` + demands a rejection and must become an acceptance. + +2. **The compiler is right; the test is wrong — ML tuple heads are flat.** + `pick : (T, U) -> T` with `pick (first, second) = first` declares a + flat two-parameter head, so `pick 1 "two"` is not a curried + application of it. Now stated outright in + [spec 0024](../specs/0024-MLFlavorSyntax.md) `[FLAVOR-ML-CURRY]` with both + the accepted and the rejected spelling. + `generics_apply_ml_tests.rs::ml_type_application_survives_curried_application` + must call `pick (1, "two")`. + +3. **The compiler is right; the test is wrong — dynamic effects infer their + instantiation.** A written instantiation *is* the identity, so only a + `static effect` may carry one at a `perform` or a `handle`; a row may pin in + either stage. That a runtime key happens to be mangled per instantiation + does not license the written form. Now stated with accepted/rejected + examples in [spec 0035](../specs/0035-StagedEffects.md) + `[STAGE-SIGNALS-EXACT]`. + `generic_effects_tests.rs::a_bracketed_row_carries_several_generic_entries` + writes `handle Read` on a dynamic effect and must drop the arguments. + +4. **The compiler is right; the test is wrong — handler identity is exact.** + A `Stash` handler does not discharge a `Stash` request, so + `unhandled effect operations` is the truthful diagnostic; effect names + matching is not effect identities matching. + `generic_effects_tests.rs::a_handler_arm_disagreeing_with_the_body_is_rejected` + expects `cannot unify` and must instead put the disagreeing arm on a + *direct* `perform` under the handler, where the arm and the operation's + return really do meet. + +5. **The compiler is right; the corpus program is wrong — double flip is an + output position.** `type Sink` carries + `hof: ((T) -> int) -> int`. A field is read out of the record (+), the + outer function's argument flips it (−) and the inner function's argument + flips it back (+), so `T` lands in output position and `in T` forbids it. + `type_equality_comprehensive.test.osp` line 124 must give `hof` a shape + that keeps `T` negative. + +6. **Three ML fixtures never reach the ML parser.** + `ml_turbofish_type_arg_arity.ospo`, `ml_turbofish_no_declared_binder.ospo` + and `ml_variance_covariant_no_inward_coercion.ospo` lack the + `// osprey: flavor=ml` marker that every other `ml_*.ospo` carries. The + `.ospo` extension resolves to Default ([`resolve_flavor`]), so they are + parsed as Default and emit a page of syntax errors instead of the + diagnostic they assert. The `ml_` prefix is a naming convention only — it + selects nothing. + +7. **The stage diagnostic's phase is asserted twice, incompatibly.** + `crates/osprey-syntax/src/lib.rs`'s + `an_instantiated_dynamic_effect_is_rejected_rather_than_shared` requires the + rejection in `parse_program_with_flavor(...).errors`, while + `generic_effects_tests.rs::a_written_instantiation_on_a_dynamic_perform_is_rejected` + requires it from the checker. Both cannot hold. Until the freeze lifts the + diagnostic stays where it is — a stage rule reading as a `SyntaxError` is a + layering wart, but moving it changes a published phase contract. + +8. **A stale golden.** `stage_signal_instantiated_dynamic_effect.ospo.expectedoutput` + still carries the superseded "keyed by effect name at runtime, so + instantiations share one key" rationale; `crates/osprey-ast/src/stage.rs` + already emits the replacement prose. The golden is the stale side. + +9. **The compiler is right; the ML twin is wrong — ML has no brace expression.** + `type_equality_comprehensive.test.ospml` line 233 writes a Default-flavor + map literal, `identityOf>> { "a": [1], "b": [2] }`. + ML builds a map with `[k => v]`; `{` lexes only so a structural PATTERN can + spell `{ heading, .. }` and has no expression form at all — the rule + `examples/failscompilation/ml_brace_record_and_question_sigil.ospo` exists to + pin. The line must become `[ "a" => [1], "b" => [2] ]` — verified: with that + spelling the whole application parses, type-checks and runs, so the triple + `>` and the call-site type arguments are not implicated. + +Fixed in this sweep rather than recorded, because no test asserted the broken +behaviour: a glued `<` after a name committed to call-site type arguments with +no lookahead, so `x<3` and `x int -> string` is redundant on one function and load-bearing on the next. It is decided by inference, and only by inference. -**The decision procedure.** For each annotation, replace it with a fresh type -variable, solve the enclosing definition, and generalise. Compare the result to -the type that was written, up to renaming of bound type variables. Equal ⇒ -redundant. More general ⇒ the annotation was constraining something and is -kept. Ill-typed without it ⇒ kept. +**The decision procedure.** Start from a well-typed program. Erase exactly one written parameter, return, lambda, or binding annotation from a copy of that program and run inference again. Compare all solved function, binding, lambda, list, handler, and operation types, including effect arguments and the relationships between declared generic binders and those types. The comparison uses one consistent bijection between inference variables. Report a warning only when the copied program remains well-typed and every compared type is equal under that renaming. Any changed type, changed binder relationship, or type error keeps the annotation. + +Each warning is evaluated against the original program with its other annotations present. Several independent warnings do not prove that all their annotations can be removed together. For example, either annotation in `fn identity(x: T) -> T = x` can individually be inferred from the other; deleting both would disconnect the declared `T` from the function's parameter. Re-run diagnostics after a deletion. An ML signature header is one source construct containing several canonical slots; deleting its whole header requires checking the whole edit. ```mermaid flowchart LR @@ -913,11 +911,11 @@ surfaces ([FLAVOR-BOUNDARY]) — an ML `f : string -> int` header and a Default identically. ```osprey-ml -// redundant: `quote key + ":" + toString value` already fixes every slot. -numField : string -> int -> string -numField key value = quote key + ":" + toString value +(** Both slots are inferred as string from concatenation. *) +decorate : string -> string +decorate text = text + "!" -// kept: the empty literal constrains nothing on its own. +(** Kept: the empty literal constrains nothing on its own. *) seen : List seen = [] ``` @@ -926,14 +924,21 @@ seen = [] declaration rather than as a constraint on an inferred one, and no annotation in them is ever reported: -- a `signature` block's members ([MODULES-SIGNATURE](0025-ModulesAndNamespaces.md#signatures-modules-signature)) — a signature *is* the module's public contract, and a module body that repeats one of its types is judged like any other function; +- a `signature` block's members ([MODULES-SIGNATURE](0025-ModulesAndNamespaces.md#signatures-modules-signature)) — a signature *is* the module's public contract. Elaboration copies a signature's types onto the members that left them off, and it marks every type it supplies, so a member that wrote nothing is never blamed for the copy. A member that *writes* the same type again is judged like any other function: that duplicate is a real line, and deleting it changes nothing; - record field declarations and union variant payloads, whose types are their definition; - `extern` and foreign declarations ([Foreign Function Interface](0019-ForeignFunctionInterface.md)), which have no body to infer from; -- an annotation whose erasure leaves a free type variable the solver never grounds. +- an annotation whose erasure changes a type variable's constraints or its relationship to a declared binder. + +Types inserted by module-signature elaboration are compiler-generated constraints and never receive a redundancy warning. A written annotation in a module body is checked normally, even if its spelling equals the module's signature. The compiler records this provenance when it inserts a constraint; matching member names or type spellings is not evidence that an annotation was generated. An annotation that would erase a `Result` is not redundant either — it is a type error ([Result Preservation](#result-preservation)), reported as one. +**An ill-typed program reports none.** The types inferred for a program that +does not typecheck are the checker's best effort at code it has already +rejected, and no comparison drawn from them would be trustworthy. Type errors +come first; the redundancy pass runs on programs that pass. + **Severity.** The diagnostic is a **Warning**. It changes no exit code and no generated code: a program whose only diagnostics are redundant annotations compiles and runs exactly as it did. Severity is fixed today and becomes @@ -941,13 +946,23 @@ configurable per rule; the rule identifier is `redundant-annotation`, and it is that identifier a future configuration names. **The message** identifies the annotation and prints the type inference derives -without it, so the fix is to delete the annotation and nothing else: +without that slot. There is +one line per slot the rule judges: ``` -warning: redundant type annotation on `numField`: inference derives `(string, int) -> string` without it +redundant type annotation on parameter `key` of `numField`: inference derives `string` without it +redundant return type annotation on `numField`: inference derives `string` without it +redundant type annotation on `seen`: inference derives `List` without it ``` -Every front end reports it: `osprey build` and `osprey check` on stderr, and -the language server as a Warning diagnostic spanning the annotation alone -([LSP-DIAGNOSTICS](0020-LanguageServerAndEditors.md#diagnostics-lsp-diagnostics)), so the squiggle covers -the text to delete. +An annotation written on an anonymous function names `` as its owner, +and a name that assembly mangled is reported in its source spelling +([MODULES-ABI](0025-ModulesAndNamespaces.md#name-mangling-and-abi-modules-abi)), +so `bank::Api::json` is never shown as its encoded symbol. + +Every front end reports it: `osprey build` and `osprey FILE --check` on stderr, +grouped by source file under an aligned `line:column` gutter and closed by a +count and the rules that raised it; and the language server as a Warning +diagnostic anchored at the containing declaration and spanning the rest of that source line +([LSP-DIAGNOSTICS](0020-LanguageServerAndEditors.md#diagnostics-lsp-diagnostics)), +The message names the parameter, return, or binding slot. The range identifies the declaration; it is not a deletion edit. The compiler does not offer an automatic bulk deletion based on these independent warnings. diff --git a/docs/specs/0012-Built-InFunctions.md b/docs/specs/0012-Built-InFunctions.md index d64b2f1f..5d705687 100644 --- a/docs/specs/0012-Built-InFunctions.md +++ b/docs/specs/0012-Built-InFunctions.md @@ -72,19 +72,22 @@ editor integration are specified in [Testing Framework](0027-TestingFramework.md ## Numeric Functions -The numeric builtins are inside the arithmetic totality guarantee: none may trap, panic, wrap silently, or return an unspecified value ([ARITH-TOTAL](0037-ArithmeticEffects.md#the-guarantee--arith-total)). `abs` and `intDiv` follow the operators — plain `int`, with faults dispatched to the `Arith` handler. `checkedAdd`/`checkedSub`/`checkedMul` return a `Result` and are the explicit value-level form for code that wants overflow as data. +The numeric builtins are inside the arithmetic totality guarantee: none may trap, panic, wrap silently, or return an unspecified value ([ARITH-TOTAL](0037-ArithmeticEffects.md#the-guarantee--arith-total)). `abs` and `intDiv` follow the operators, so whatever the operators return, they return. `checkedAdd`/`checkedSub`/`checkedMul` are the explicit value-level form for code that wants overflow as data, and keep the runtime's generic `Error` channel. -### `abs(n: int) -> int` — [BUILTIN-ABS] Returns the absolute value. Because `2^63` is not representable, the minimum signed 64-bit input performs `Arith.overflow`; it never wraps or panics. +**What ships today is the checked-`Result` form.** `abs` and `intDiv` return `Result` — the same `MathError` channel the arithmetic operators use, because a division fault is a math fault and not a runtime fault — and a caller discharges it with `match` or `?:`. [Plan 0027](../plans/0027-arithmetic-effects.md) retires that shape in favour of a plain `int` whose faults dispatch to a compiler-declared `Arith` handler, which is what [spec 0037](0037-ArithmeticEffects.md) specifies as the normative target; **no part of it is implemented yet**. The signatures below are written in the shipped form, and the `Arith.*` faults name what each one performs once that plan lands. -### `intDiv(a: int, b: int) -> int` — [BUILTIN-INTDIV] -Truncates toward zero. A zero divisor performs `Arith.remainderByZero`; `intDiv(-9223372036854775808, -1)` performs `Arith.overflow`; every other input yields the quotient. The `/` operator instead returns `float`. +### `abs(n: int) -> Result` — [BUILTIN-ABS] +Returns the absolute value. Because `2^63` is not representable, the minimum signed 64-bit input is the `Error` case (`Arith.overflow` under plan 0027); it never wraps or panics. + +### `intDiv(a: int, b: int) -> Result` — [BUILTIN-INTDIV] +Truncates toward zero. A zero divisor is the `Error` case (`Arith.remainderByZero`), as is `intDiv(-9223372036854775808, -1)` (`Arith.overflow`); every other input yields the quotient. The `/` operator instead returns `float`. ```osprey -intDiv(7, 2) // 3 -intDiv(255643, 10) // 25564 -intDiv(5, 0) // performs Arith.remainderByZero -intDiv(-9223372036854775808, -1) // performs Arith.overflow -fn half(n) = intDiv(n, 2) +intDiv(7, 2) ?: 0 // 3 +intDiv(255643, 10) ?: 0 // 25564 +intDiv(5, 0) // Error — division by zero +intDiv(-9223372036854775808, -1) // Error — integer overflow +fn half(n) = intDiv(n, 2) ?: 0 ``` ### `toFloat(n: int) -> float` — [BUILTIN-TOFLOAT] diff --git a/docs/specs/0024-MLFlavorSyntax.md b/docs/specs/0024-MLFlavorSyntax.md index 4fbb721f..7ba61e93 100644 --- a/docs/specs/0024-MLFlavorSyntax.md +++ b/docs/specs/0024-MLFlavorSyntax.md @@ -97,6 +97,28 @@ it. The parenthesised list is a tuple known head is exactly this flat call — which is why the ML and Default twins share IR. +Currying is a property of the **declaration**, never of the call site. A head +declared flat stays flat everywhere it is applied, so juxtaposing its arguments +one at a time is not a partial application of it — there is nothing to bind one +argument to — and the program is rejected. `add 10 20` above is not another +spelling of `add (10, 20)`: the head takes one two-element tuple, so that line +reads as applying `int` to `20` and is refused. + +Written type arguments do not change which of the two a callee is +([TYPE-GENERICS-APPLY](0004-TypeSystem.md#generics-and-variance)). They pin the +callee's binders and leave its parameter shape exactly as declared: + +```osprey-ml +pick : (T, U) -> T +pick (first, second) = first + +kept = pick (1, "two") +// pick 1 "two" is rejected for the same reason `add 10 20` is. +``` + +Reach for whitespace parameters when partial application is wanted, and for a +parenthesised list when it is not. + Lambdas follow the same split: `\x y => body` is curried and `\(x, y) => body` is flat. `name () = body` is a zero-parameter function; `name = body` is a value binding. @@ -217,6 +239,33 @@ An effect declaration lowers to `Stmt::Effect`; a performance lowers to `Expr::Perform`. `resume` and `resume value` lower to `Expr::Resume` inside a handler arm. +`[FLAVOR-ML-EFFECT-OP-NAME]` Operation names are their own namespace. Exactly +three positions hold one, and each admits nothing else, so a word this flavor +reserves elsewhere still names an operation in all three: + +1. the name on an operation line of an `effect` block, +2. the name after the dot in `perform Effect.name`, +3. the head of a handler arm. + +```osprey-ml +effect Chan T + send : T => Unit + select : Unit => T + +relay x = + handle Chan + send v => print "sent ${v}" + select => x + in perform Chan.send x +``` + +This is the rule `abort` / `once` / `many` / `replayable` already follow under +[FLAVOR-ML-EFFECT-ANNOTATIONS](#effects): a marker is a marker only when another +name follows it, so `abort : string => Unit` declares an operation *called* +`abort`. Every other position keeps its ordinary meaning — `send`, `recv` and +`select` remain the channel forms wherever an expression is expected, and +`handler` and `do` stay reserved and name nothing. + `[FLAVOR-ML-EFFECT-ANNOTATIONS]` An effect declaration carries two axes beyond its operations, and ML spells both as prefix keywords: `static` before `effect` fixes the stage diff --git a/docs/specs/0035-StagedEffects.md b/docs/specs/0035-StagedEffects.md index 540da1e8..552d752c 100644 --- a/docs/specs/0035-StagedEffects.md +++ b/docs/specs/0035-StagedEffects.md @@ -420,6 +420,32 @@ under-approximating: - A row variable that is not yet instantiated has no dependency set. The dependency set of a stage-polymorphic function is known at each call site, not at its definition. +- **Where an instantiation may be written.** A written instantiation *is* the + identity, so only a `static effect` may carry one at a request or a handler: + `perform Signal.read()` and `handle Signal` name a static + effect. A **dynamic** effect takes its instantiation from inference and both + its mention forms omit the arguments — `perform Signal.read()` and + `handle Signal` — because a runtime handler is installed under a key the + source did not write. A **row** is the exception in the other direction: it + states a type, not a mention, so `!Signal` and `![Read, Write]` + pin their arguments in either stage. + + ```osprey + effect Stash { take: fn() -> T } + + // Accepted — the row pins, the mentions infer. + fn held() !Stash = perform Stash.take() + fn main() = print("${handle Stash take => 9 do held()}") + + // Rejected — `Stash` is dynamic, so neither mention may write ``: + // perform Stash.take() + // handle Stash take => 9 do ... + ``` + + That a runtime handler key happens to be mangled per instantiation does not + license the written form: the key is an implementation of the identity, not a + second way to spell it. Declare `static effect Stash` when the program needs + to name one instantiation apart from another. `[STAGE-SIGNALS-REBUILD]` A UI framework consuming this uses the dependency set as its dirty set directly: when a signal changes, the subtrees to rebuild are diff --git a/tests/MOBILE_UNPORTABLE.txt b/tests/MOBILE_UNPORTABLE.txt index aa988e49..a5bab205 100644 --- a/tests/MOBILE_UNPORTABLE.txt +++ b/tests/MOBILE_UNPORTABLE.txt @@ -30,6 +30,8 @@ # legal C spelling. tests/effects/errors/direct_recovery.test.osp C ABI: unhandled effect operations at library export `requirePositive`: RecoveryError.missingInt; add a matching `handle` tests/effects/errors/direct_recovery.test.ospml C ABI: unhandled effect operations at library export `requirePositive`: RecoveryError.missingInt; add a matching `handle` +tests/effects/injection/storage_injection.test.osp C ABI: unhandled effect operations at library export `countNotes`: Storage.exists, Storage.load; add a matching `handle` +tests/effects/injection/storage_injection.test.ospml C ABI: unhandled effect operations at library export `countNotes`: Storage.exists, Storage.load; add a matching `handle` tests/effects/multiplicity/multiplicity.test.osp a continuation for `Charge.charge` (a suspended continuation cannot cross or outlive a synchronous host call) tests/effects/multiplicity/multiplicity.test.ospml a continuation for `Charge.charge` (a suspended continuation cannot cross or outlive a synchronous host call) tests/effects/resume/resume_abort_early_exit.test.osp a continuation for `Stop.check` (a suspended continuation cannot cross or outlive a synchronous host call) diff --git a/tests/effects/README.md b/tests/effects/README.md index ccf1876b..8ca6421f 100644 --- a/tests/effects/README.md +++ b/tests/effects/README.md @@ -36,6 +36,24 @@ Returning `42` here does **not** stop `load`. It supplies a value and lets that rule across nested policies, repeated failures, handler-owned state, multiple result types, recursion and outer effects. +Because `handle … in` is an expression, the policy does not have to be written +where the logic is. A function that returns one is an implementation the caller +passes in: + +```osprey +fn withDiskStorage(action) = handle Storage + save key contents => writeFile(key, contents) ?: 0 + load key => readFile(key) ?: "" +in action() +``` + +The same logic then runs against the real file system, against an in-memory +test double that records every call, or against a policy that refuses to write +— chosen at the call site, with no change to the code performing the +operations. The paired [injection suites](injection/README.md) hold that +pattern end to end, including the mock verification a file system cannot +offer. + ### Explicit resume and early exit If any arm in a handler region contains `resume`, Osprey runs the handled code diff --git a/tests/effects/injection/README.md b/tests/effects/injection/README.md new file mode 100644 index 00000000..52eb450d --- /dev/null +++ b/tests/effects/injection/README.md @@ -0,0 +1,62 @@ +# Injected implementations + +A handler is not where the implementation has to be written. `handle … in` is +an expression, so a function that returns one is a policy you pass around: +the code under test performs an operation, and the caller decides which +implementation answers it. + +`storage_injection.test.{osp,ospml}` is the whole pattern in one program. +The logic is written once against a `Storage` effect, and three separate +implementations are handed to it without the logic changing, recompiling, or +knowing which one it got: + +| Implementation | Installed by | What the arms do | +| --- | --- | --- | +| Real file system | `withDiskStorage` | `writeFile` / `readFile` | +| Test double | `withMockStorage` | An in-memory `Map`, plus call counters and an ordered call log | +| Read-only policy | `withReadOnlyStorage` | Refuses every write and serves one fixed entry | + +```osprey +// The logic performs the operation and names no implementation. +fn appendNote(book, line) !Storage = { + let updated = "${perform Storage.load(book)}${line}\n" + let _ = perform Storage.save(book, updated) + entryCount(updated) +} + +// The caller chooses one, per call. +let live = withDiskStorage(|| => appendNote("notes.txt", "buy milk")) +let mocked = withMockStorage(|| => appendNote("notes.txt", "buy milk")) +``` + +The suite asserts the two runs answer identically, that the disk run really +wrote the bytes (they are read back with `readFile` from outside the handler), +and that the mocked run touched no file system at all — `readFile` on the +mock's paths still reports `No such file or directory`. + +## Verifying calls, not just answers + +Handler arms are the only place state may be mutated, which makes the test +double the natural place to record what the logic asked for. The mock counts +each operation and appends to a call log, so the suite pins the exact sequence: + +``` +load(notes.txt);save(notes.txt,9);load(notes.txt);save(notes.txt,22);… +``` + +That is the verification a real file system cannot offer, and it is what makes +the double a mock rather than a stub: the assertions cover the calls the logic +made, their order, their arguments, and the count of each. + +## Why the effect is the seam + +Nothing is threaded through the logic to make this work — no handle parameter, +no interface record, no constructor. `appendNote` and `countNotes` name +`Storage` in their effect row and the compiler refuses to let either reach +program entry without a handler that discharges it, so the seam is checked +rather than conventional. Swapping the implementation is swapping the caller's +one word: `withDiskStorage` becomes `withMockStorage`. + +These handlers are direct-substitution handlers — no arm calls `resume` — so +each arm's value simply becomes the operation's result and the caller carries +on. See the [effects overview](../README.md) for the resuming form. diff --git a/tests/effects/injection/storage_injection.test.osp b/tests/effects/injection/storage_injection.test.osp new file mode 100644 index 00000000..b35c3d9b --- /dev/null +++ b/tests/effects/injection/storage_injection.test.osp @@ -0,0 +1,218 @@ +/// Storage names the persistence the notebook logic needs and nothing more. +/// No implementation appears here: `save`, `load` and `exists` are answered +/// by whoever installs the handler, so the logic compiles once and runs unchanged +/// against the real file system, against an in-memory test double, and against +/// a policy that refuses to write at all. +effect Storage { + /// Persist `contents` under `key`; answers the byte count stored. + save: fn(string, string) -> int + /// Load whatever `key` holds; a key holding nothing answers "". + load: fn(string) -> string + /// Report whether `key` currently holds anything. + exists: fn(string) -> bool +} + +/// Counts the newline-terminated entries in a notebook body. +fn entryCount(body) = match isEmpty(body) { + true => 0 + false => listLength(lines(trimEnd(body))) +} + +/// Appends one entry to `book` and answers the entry count after the write. +/// This is the logic under test: it performs Storage and picks no handler. +fn appendNote(book, line) !Storage = { + let updated = "${perform Storage.load(book)}${line}\n" + let _ = perform Storage.save(book, updated) + entryCount(updated) +} + +/// Answers the entries in `book`, or 0 when the book was never started. +fn countNotes(book) !Storage = match perform Storage.exists(book) { + true => entryCount(perform Storage.load(book)) + false => 0 +} + +/// Copies `book` into `archive` and answers the bytes the copy reported. +/// A book that does not exist is not copied and answers 0 bytes. +fn archiveNotes(book, archive) !Storage = match perform Storage.exists(book) { + true => perform Storage.save(archive, perform Storage.load(book)) + false => 0 +} + +/// The production implementation, passed in as a handler: every operation +/// reaches the real file system through the file builtins. +fn withDiskStorage(action) = handle Storage + save key contents => writeFile(key, contents) ?: 0 + load key => readFile(key) ?: "" + exists key => match readFile(key) { + Success { value } => !isEmpty(value) + Error { message } => false + } +in action() + +/// The test double's disk: a map that never reaches a file system, seeded +/// with one fixture entry no real file system holds. +mut mockFiles = mapSet(Map(), "fixture.txt", "seeded entry\n") +/// Call records the disk handler cannot offer, one per operation. +mut mockSaves = 0 +mut mockLoads = 0 +mut mockExistsCalls = 0 +/// The ordered call log, which is what a mock is verified against. +mut mockLog = "" + +/// The test implementation, passed in exactly like the production one. Handler +/// arms are the only place state may be mutated, so the double records every +/// call it answers. +fn withMockStorage(action) = handle Storage + save key contents => { + mockSaves = mockSaves + 1 ?: mockSaves + mockLog = "${mockLog}save(${key},${toString(byteLength(contents))});" + mockFiles = mapSet(mockFiles, key, contents) + byteLength(contents) + } + load key => { + mockLoads = mockLoads + 1 ?: mockLoads + mockLog = "${mockLog}load(${key});" + mapGet(mockFiles, key) ?: "" + } + exists key => { + mockExistsCalls = mockExistsCalls + 1 ?: mockExistsCalls + mockLog = "${mockLog}exists(${key});" + mapContains(mockFiles, key) + } +in action() + +/// A third implementation: a read-only policy that accepts no write and serves +/// one fixed entry. The logic is not recompiled, edited or told about it. +fn withReadOnlyStorage(action) = handle Storage + save key contents => 0 + load key => "locked entry\n" + exists key => true +in action() + +/// The path each flavor owns, so the Default and ML twins never share a file. +let diskBook = "osprey_storage_injection_default.txt" +let diskArchive = "osprey_storage_injection_default_archive.txt" + +/// This case runs the logic against the real file system and verifies the +/// bytes with `readFile` from outside the handler. +fn diskStorageCase() = { + // Truncate both paths so a rerun starts from the same file system state. + let clearedBook = writeFile(diskBook, "") ?: (0 - 1 ?: 0) + let clearedArchive = writeFile(diskArchive, "") ?: (0 - 1 ?: 0) + let first = withDiskStorage(|| => appendNote(diskBook, "buy milk")) + let second = withDiskStorage(|| => appendNote(diskBook, "call dentist")) + let counted = withDiskStorage(|| => countNotes(diskBook)) + let archived = withDiskStorage(|| => archiveNotes(diskBook, diskArchive)) + let onDisk = readFile(diskBook) ?: "" + let archivedOnDisk = readFile(diskArchive) ?: "" + let missing = withDiskStorage(|| => countNotes("osprey_storage_injection_absent.txt")) + + // The logic's answers come back through the injected disk implementation. + checkAll("disk implementation answers", [ + clearedBook == 0, + clearedArchive == 0, + first == 1, + second == 2, + counted == 2, + archived == byteLength(onDisk), + missing == 0 + ]) + + // The file system really was written: these bytes are read back directly. + checkAll("disk implementation side effects", [ + onDisk == "buy milk\ncall dentist\n", + archivedOnDisk == onDisk, + byteLength(onDisk) == 22, + contains(onDisk, "buy milk\n"), + endsWith(onDisk, "call dentist\n"), + entryCount(onDisk) == 2 + ]) +} + +// Register the production implementation against the real file system. +test("injected disk handler persists the notebook to real files", diskStorageCase) + +/// This case runs the identical logic against the in-memory double and +/// verifies both the answers and the calls the logic made. +fn mockStorageCase() = { + let first = withMockStorage(|| => appendNote("notes.txt", "buy milk")) + let second = withMockStorage(|| => appendNote("notes.txt", "call dentist")) + let counted = withMockStorage(|| => countNotes("notes.txt")) + let archived = withMockStorage(|| => archiveNotes("notes.txt", "archive.txt")) + let missing = withMockStorage(|| => countNotes("never-written.txt")) + let fixture = withMockStorage(|| => countNotes("fixture.txt")) + let stored = mapGet(mockFiles, "notes.txt") ?: "" + + // Every answer matches the disk run above: same logic, same results. + checkAll("mock answers match the disk implementation", [ + first == 1, + second == 2, + counted == 2, + archived == 22, + missing == 0, + fixture == 1, + stored == "buy milk\ncall dentist\n", + (mapGet(mockFiles, "archive.txt") ?: "") == stored + ]) + + // Verification a real file system cannot offer: which calls were made. + checkAll("mock recorded every call", [ + mockSaves == 3, + mockLoads == 5, + mockExistsCalls == 4, + mapLength(mockFiles) == 3, + !mapContains(mockFiles, "never-written.txt"), + mockLog == "load(notes.txt);save(notes.txt,9);load(notes.txt);save(notes.txt,22);exists(notes.txt);load(notes.txt);exists(notes.txt);load(notes.txt);save(archive.txt,22);exists(never-written.txt);exists(fixture.txt);load(fixture.txt);", + startsWith(mockLog, "load(notes.txt);save(notes.txt,9);"), + contains(mockLog, "save(archive.txt,22);"), + endsWith(mockLog, "load(fixture.txt);") + ]) + + // The double touched no file system: nothing named by the test exists. + let notesAbsent = match readFile("notes.txt") { + Success { value } => false + Error { message } => contains(message, "No such file or directory") + } + let archiveAbsent = match readFile("archive.txt") { + Success { value } => false + Error { message } => contains(message, "readFile") + } + checkAll("mock touched no file system", [ + notesAbsent, + archiveAbsent + ]) +} + +// Register the test double standing in for the file system. +test("injected mock handler replaces the file system and records every call", mockStorageCase) + +/// This case swaps in a third policy to show the logic is unchanged by it. +fn readOnlyStorageCase() = { + let savesBefore = mockSaves + let appended = withReadOnlyStorage(|| => appendNote("notes.txt", "buy milk")) + let counted = withReadOnlyStorage(|| => countNotes("notes.txt")) + let archived = withReadOnlyStorage(|| => archiveNotes("notes.txt", "archive.txt")) + + // A refused write still answers the operation's declared type, so the + // logic keeps running and reports what the policy actually stored. + checkAll("read-only policy answers", [ + appended == 2, + counted == 1, + archived == 0, + entryCount("locked entry\n") == 1 + ]) + + // Swapping the handler swapped the implementation and nothing else: the + // mock's records and the earlier disk file are untouched by this run. + checkAll("policies stay isolated", [ + mockSaves == savesBefore, + mockSaves == 3, + (mapGet(mockFiles, "notes.txt") ?: "") == "buy milk\ncall dentist\n", + !contains(mockLog, "locked"), + (readFile(diskBook) ?: "") == "buy milk\ncall dentist\n" + ]) +} + +// Register the third policy, proving the logic depends on none of them. +test("swapping the injected handler swaps the policy, not the logic", readOnlyStorageCase) diff --git a/tests/effects/injection/storage_injection.test.osp.expectedoutput b/tests/effects/injection/storage_injection.test.osp.expectedoutput new file mode 100644 index 00000000..35b0dc4e --- /dev/null +++ b/tests/effects/injection/storage_injection.test.osp.expectedoutput @@ -0,0 +1,5 @@ +ok 1 - injected disk handler persists the notebook to real files +ok 2 - injected mock handler replaces the file system and records every call +ok 3 - swapping the injected handler swaps the policy, not the logic +1..3 +# tests=3 passed=3 failed=0 skipped=0 diff --git a/tests/effects/injection/storage_injection.test.ospml b/tests/effects/injection/storage_injection.test.ospml new file mode 100644 index 00000000..38a82443 --- /dev/null +++ b/tests/effects/injection/storage_injection.test.ospml @@ -0,0 +1,210 @@ +(** Storage names the persistence the notebook logic needs and nothing more. + No implementation appears here: `save`, `load` and `exists` are answered + by whoever installs the handler, so the logic compiles once and runs unchanged + against the real file system, against an in-memory test double, and against + a policy that refuses to write at all. *) +effect Storage + (** Persist `contents` under `key`; answers the byte count stored. *) + save : (string, string) => int + (** Load whatever `key` holds; a key holding nothing answers "". *) + load : string => string + (** Report whether `key` currently holds anything. *) + exists : string => bool + +(** Counts the newline-terminated entries in a notebook body. *) +entryCount body = + match isEmpty body + true => 0 + false => listLength (lines (trimEnd body)) + +(** Appends one entry to `book` and answers the entry count after the write. + This is the logic under test: it performs Storage and picks no handler. *) +appendNote book line = + updated = "${perform Storage.load book}${line}\n" + _ = perform Storage.save book updated + entryCount updated + +(** Answers the entries in `book`, or 0 when the book was never started. *) +countNotes book = + match perform Storage.exists book + true => entryCount (perform Storage.load book) + false => 0 + +(** Copies `book` into `archive` and answers the bytes the copy reported. + A book that does not exist is not copied and answers 0 bytes. *) +archiveNotes book archive = + match perform Storage.exists book + true => perform Storage.save archive (perform Storage.load book) + false => 0 + +(** The production implementation, passed in as a handler: every operation + reaches the real file system through the file builtins. *) +withDiskStorage action = + handle Storage + save key contents => writeFile key contents ?: 0 + load key => readFile key ?: "" + exists key => + match readFile key + Success value => !(isEmpty value) + Error message => false + in action () + +(** The test double's disk: a map that never reaches a file system, seeded + with one fixture entry no real file system holds. *) +mut mockFiles = mapSet (Map ()) "fixture.txt" "seeded entry\n" +(** Call records the disk handler cannot offer, one per operation. *) +mut mockSaves = 0 +mut mockLoads = 0 +mut mockExistsCalls = 0 +(** The ordered call log, which is what a mock is verified against. *) +mut mockLog = "" + +(** The test implementation, passed in exactly like the production one. Handler + arms are the only place state may be mutated, so the double records every + call it answers. *) +withMockStorage action = + handle Storage + save key contents => + mockSaves := mockSaves + 1 ?: mockSaves + mockLog := "${mockLog}save(${key},${toString (byteLength contents)});" + mockFiles := mapSet mockFiles key contents + byteLength contents + load key => + mockLoads := mockLoads + 1 ?: mockLoads + mockLog := "${mockLog}load(${key});" + mapGet mockFiles key ?: "" + exists key => + mockExistsCalls := mockExistsCalls + 1 ?: mockExistsCalls + mockLog := "${mockLog}exists(${key});" + mapContains mockFiles key + in action () + +(** A third implementation: a read-only policy that accepts no write and serves + one fixed entry. The logic is not recompiled, edited or told about it. *) +withReadOnlyStorage action = + handle Storage + save key contents => 0 + load key => "locked entry\n" + exists key => true + in action () + +(** The path each flavor owns, so the Default and ML twins never share a file. *) +diskBook = "osprey_storage_injection_ml.txt" +diskArchive = "osprey_storage_injection_ml_archive.txt" + +(** This case runs the logic against the real file system and verifies the + bytes with `readFile` from outside the handler. *) +diskStorageCase () = + // Truncate both paths so a rerun starts from the same file system state. + clearedBook = writeFile diskBook "" ?: (0 - 1 ?: 0) + clearedArchive = writeFile diskArchive "" ?: (0 - 1 ?: 0) + first = withDiskStorage (\() => appendNote diskBook "buy milk") + second = withDiskStorage (\() => appendNote diskBook "call dentist") + counted = withDiskStorage (\() => countNotes diskBook) + archived = withDiskStorage (\() => archiveNotes diskBook diskArchive) + onDisk = readFile diskBook ?: "" + archivedOnDisk = readFile diskArchive ?: "" + missing = withDiskStorage (\() => countNotes "osprey_storage_injection_absent.txt") + + // The logic's answers come back through the injected disk implementation. + checkAll "disk implementation answers" [ + clearedBook == 0, + clearedArchive == 0, + first == 1, + second == 2, + counted == 2, + archived == byteLength onDisk, + missing == 0 + ] + + // The file system really was written: these bytes are read back directly. + checkAll "disk implementation side effects" [ + onDisk == "buy milk\ncall dentist\n", + archivedOnDisk == onDisk, + byteLength onDisk == 22, + contains onDisk "buy milk\n", + endsWith onDisk "call dentist\n", + entryCount onDisk == 2 + ] + +test "injected disk handler persists the notebook to real files" diskStorageCase + +(** This case runs the identical logic against the in-memory double and + verifies both the answers and the calls the logic made. *) +mockStorageCase () = + first = withMockStorage (\() => appendNote "notes.txt" "buy milk") + second = withMockStorage (\() => appendNote "notes.txt" "call dentist") + counted = withMockStorage (\() => countNotes "notes.txt") + archived = withMockStorage (\() => archiveNotes "notes.txt" "archive.txt") + missing = withMockStorage (\() => countNotes "never-written.txt") + fixture = withMockStorage (\() => countNotes "fixture.txt") + stored = mapGet mockFiles "notes.txt" ?: "" + + // Every answer matches the disk run above: same logic, same results. + checkAll "mock answers match the disk implementation" [ + first == 1, + second == 2, + counted == 2, + archived == 22, + missing == 0, + fixture == 1, + stored == "buy milk\ncall dentist\n", + (mapGet mockFiles "archive.txt" ?: "") == stored + ] + + // Verification a real file system cannot offer: which calls were made. + checkAll "mock recorded every call" [ + mockSaves == 3, + mockLoads == 5, + mockExistsCalls == 4, + mapLength mockFiles == 3, + !(mapContains mockFiles "never-written.txt"), + mockLog == "load(notes.txt);save(notes.txt,9);load(notes.txt);save(notes.txt,22);exists(notes.txt);load(notes.txt);exists(notes.txt);load(notes.txt);save(archive.txt,22);exists(never-written.txt);exists(fixture.txt);load(fixture.txt);", + startsWith mockLog "load(notes.txt);save(notes.txt,9);", + contains mockLog "save(archive.txt,22);", + endsWith mockLog "load(fixture.txt);" + ] + + // The double touched no file system: nothing named by the test exists. + notesAbsent = + match readFile "notes.txt" + Success value => false + Error message => contains message "No such file or directory" + archiveAbsent = + match readFile "archive.txt" + Success value => false + Error message => contains message "readFile" + checkAll "mock touched no file system" [ + notesAbsent, + archiveAbsent + ] + +test "injected mock handler replaces the file system and records every call" mockStorageCase + +(** This case swaps in a third policy to show the logic is unchanged by it. *) +readOnlyStorageCase () = + savesBefore = mockSaves + appended = withReadOnlyStorage (\() => appendNote "notes.txt" "buy milk") + counted = withReadOnlyStorage (\() => countNotes "notes.txt") + archived = withReadOnlyStorage (\() => archiveNotes "notes.txt" "archive.txt") + + // A refused write still answers the operation's declared type, so the + // logic keeps running and reports what the policy actually stored. + checkAll "read-only policy answers" [ + appended == 2, + counted == 1, + archived == 0, + entryCount "locked entry\n" == 1 + ] + + // Swapping the handler swapped the implementation and nothing else: the + // mock's records and the earlier disk file are untouched by this run. + checkAll "policies stay isolated" [ + mockSaves == savesBefore, + mockSaves == 3, + (mapGet mockFiles "notes.txt" ?: "") == "buy milk\ncall dentist\n", + !(contains mockLog "locked"), + (readFile diskBook ?: "") == "buy milk\ncall dentist\n" + ] + +test "swapping the injected handler swaps the policy, not the logic" readOnlyStorageCase From f237ad9de93f8613e91eccff49b03b70e13d569a Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 9 Sep 2026 22:04:37 +1000 Subject: [PATCH 08/10] fixes --- tree-sitter-osprey/grammar.js | 6 +- tree-sitter-osprey/src/grammar.json | 15 +- tree-sitter-osprey/src/parser.c | 25331 +++++++++++++------------- tree-sitter-osprey/src/scanner.c | 45 + 4 files changed, 12695 insertions(+), 12702 deletions(-) diff --git a/tree-sitter-osprey/grammar.js b/tree-sitter-osprey/grammar.js index ddf8d49f..7a3f5739 100644 --- a/tree-sitter-osprey/grammar.js +++ b/tree-sitter-osprey/grammar.js @@ -46,7 +46,7 @@ module.exports = grammar({ // statements, so `let r = add 2 3` silently split into // `let r = add` plus the orphans `2` and `3` // [LEX-STATEMENT-BREAK]. - externals: ($) => [$._call_open_gap, $._statement_break], + externals: ($) => [$._call_open_gap, $._statement_break, $._type_application_ahead], conflicts: ($) => [ // `abort` / `once` / `many` / `replayable` opening an operation line are @@ -586,8 +586,8 @@ module.exports = grammar({ type_constructor: ($) => prec.dynamic(1, seq(field('name', choice($.qualified_path, $.identifier)), optional($.type_arguments), '{', $.field_assignments, '}')), - type_arguments: ($) => seq(token.immediate('<'), $.type_list, '>'), - _call_type_arguments: ($) => seq(token.immediate('<'), alias($._call_type_list, $.type_list), '>'), + type_arguments: ($) => seq('<', $.type_list, '>'), + _call_type_arguments: ($) => seq($._type_application_ahead, token.immediate('<'), alias($._call_type_list, $.type_list), '>'), // Keep misplaced declaration markers visible for a precise diagnostic. _call_type_list: ($) => sep1(',', seq(optional(field('variance', choice('in', 'out'))), $._type)), diff --git a/tree-sitter-osprey/src/grammar.json b/tree-sitter-osprey/src/grammar.json index 869ef67f..4e2fcc9c 100644 --- a/tree-sitter-osprey/src/grammar.json +++ b/tree-sitter-osprey/src/grammar.json @@ -3424,11 +3424,8 @@ "type": "SEQ", "members": [ { - "type": "IMMEDIATE_TOKEN", - "content": { - "type": "STRING", - "value": "<" - } + "type": "STRING", + "value": "<" }, { "type": "SYMBOL", @@ -3443,6 +3440,10 @@ "_call_type_arguments": { "type": "SEQ", "members": [ + { + "type": "SYMBOL", + "name": "_type_application_ahead" + }, { "type": "IMMEDIATE_TOKEN", "content": { @@ -5286,6 +5287,10 @@ { "type": "SYMBOL", "name": "_statement_break" + }, + { + "type": "SYMBOL", + "name": "_type_application_ahead" } ], "inline": [], diff --git a/tree-sitter-osprey/src/parser.c b/tree-sitter-osprey/src/parser.c index 6792f2a6..61d1457d 100644 --- a/tree-sitter-osprey/src/parser.c +++ b/tree-sitter-osprey/src/parser.c @@ -5,15 +5,15 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 1761 +#define STATE_COUNT 1754 #define LARGE_STATE_COUNT 21 -#define SYMBOL_COUNT 220 +#define SYMBOL_COUNT 221 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 86 -#define EXTERNAL_TOKEN_COUNT 2 +#define TOKEN_COUNT 87 +#define EXTERNAL_TOKEN_COUNT 3 #define FIELD_COUNT 49 #define MAX_ALIAS_SEQUENCE_LENGTH 14 -#define PRODUCTION_ID_COUNT 198 +#define PRODUCTION_ID_COUNT 199 enum ts_symbol_identifiers { sym_identifier = 1, @@ -101,140 +101,141 @@ enum ts_symbol_identifiers { sym_line_comment = 83, sym__call_open_gap = 84, sym__statement_break = 85, - sym_source_file = 86, - sym_statement = 87, - sym_import_statement = 88, - sym_legacy_import_path = 89, - sym_import_target = 90, - sym_import_tail = 91, - sym_import_member_list = 92, - sym_import_member = 93, - sym_namespace_name = 94, - sym_namespace_declaration = 95, - sym_namespace_body = 96, - sym_let_declaration = 97, - sym_assignment = 98, - sym_function_declaration = 99, - sym_extern_declaration = 100, - sym_extern_parameter_list = 101, - sym_extern_parameter = 102, - sym_parameter_list = 103, - sym_parameter = 104, - sym_type_declaration = 105, - sym_type_parameter_list = 106, - sym_type_parameter = 107, - sym_union_type = 108, - sym_type_alias = 109, - sym_variant = 110, - sym_positional_payload = 111, - sym_record_type = 112, - sym_field_declarations = 113, - sym_field_declaration = 114, - sym_type_validation = 115, - sym_effect_declaration = 116, - sym_multiplicity = 117, - sym_operation_declaration = 118, - sym_effect_set = 119, - sym_effect_list = 120, - sym_effect_ref = 121, - sym__type = 122, - sym_function_type = 123, - sym_generic_type = 124, - sym_array_type = 125, - sym_type_identifier = 126, - sym_type_list = 127, - sym_expression_statement = 128, - sym_expression = 129, - sym_match_expression = 130, - sym_match_arm = 131, - sym_if_expression = 132, - sym_handler_expression = 133, - sym_handler_arm = 134, - sym_handler_params = 135, - sym_kernel_expression = 136, - sym_kernel_arm = 137, - sym_select_expression = 138, - sym_select_arm = 139, - sym_ternary_expression = 140, - sym_binary_expression = 141, - sym_unary_expression = 142, - sym_pipe_expression = 143, - sym_call_expression = 144, - sym_argument_list = 145, - sym_named_argument_list = 146, - sym_named_argument = 147, - sym_primary_expression = 148, - sym_spawn_expression = 149, - sym_yield_expression = 150, - sym_await_call = 151, - sym_send_call = 152, - sym_recv_call = 153, - sym_perform_expression = 154, - sym_resume_expression = 155, - sym_type_constructor = 156, - sym_type_arguments = 157, - sym__call_type_arguments = 158, - sym__call_type_list = 159, - sym_update_expression = 160, - sym_field_assignments = 161, - sym_field_assignment = 162, - sym_block = 163, - sym_object_literal = 164, - sym_lambda_expression = 165, - sym_literal = 166, - sym_list_literal = 167, - sym_map_literal = 168, - sym_map_entry = 169, - sym_pattern = 170, - sym_structural_pattern = 171, - sym_tuple_pattern = 172, - sym_list_pattern = 173, - sym_field_pattern = 174, - sym_module_declaration = 175, - sym_signature_ascription = 176, - sym_module_item = 177, - sym_export_declaration = 178, - sym__module_declaration = 179, - sym_signature_declaration = 180, - sym_signature_item = 181, - sym_signature_value = 182, - sym_signature_function = 183, - sym_signature_type = 184, - sym_signature_module = 185, - sym_qualified_path = 186, - sym_symbol_path = 187, - sym_boolean = 188, - sym_doc_comment = 189, - aux_sym_source_file_repeat1 = 190, - aux_sym_legacy_import_path_repeat1 = 191, - aux_sym_import_target_repeat1 = 192, - aux_sym_import_member_list_repeat1 = 193, - aux_sym_extern_parameter_list_repeat1 = 194, - aux_sym_parameter_list_repeat1 = 195, - aux_sym_type_parameter_list_repeat1 = 196, - aux_sym_union_type_repeat1 = 197, - aux_sym_positional_payload_repeat1 = 198, - aux_sym_field_declarations_repeat1 = 199, - aux_sym_effect_declaration_repeat1 = 200, - aux_sym_effect_list_repeat1 = 201, - aux_sym_match_expression_repeat1 = 202, - aux_sym_handler_expression_repeat1 = 203, - aux_sym_handler_params_repeat1 = 204, - aux_sym_kernel_expression_repeat1 = 205, - aux_sym_select_expression_repeat1 = 206, - aux_sym_argument_list_repeat1 = 207, - aux_sym_named_argument_list_repeat1 = 208, - aux_sym__call_type_list_repeat1 = 209, - aux_sym_field_assignments_repeat1 = 210, - aux_sym_map_literal_repeat1 = 211, - aux_sym_pattern_repeat1 = 212, - aux_sym_tuple_pattern_repeat1 = 213, - aux_sym_list_pattern_repeat1 = 214, - aux_sym_field_pattern_repeat1 = 215, - aux_sym_module_declaration_repeat1 = 216, - aux_sym_signature_declaration_repeat1 = 217, - aux_sym_qualified_path_repeat1 = 218, - aux_sym_doc_comment_repeat1 = 219, + sym__type_application_ahead = 86, + sym_source_file = 87, + sym_statement = 88, + sym_import_statement = 89, + sym_legacy_import_path = 90, + sym_import_target = 91, + sym_import_tail = 92, + sym_import_member_list = 93, + sym_import_member = 94, + sym_namespace_name = 95, + sym_namespace_declaration = 96, + sym_namespace_body = 97, + sym_let_declaration = 98, + sym_assignment = 99, + sym_function_declaration = 100, + sym_extern_declaration = 101, + sym_extern_parameter_list = 102, + sym_extern_parameter = 103, + sym_parameter_list = 104, + sym_parameter = 105, + sym_type_declaration = 106, + sym_type_parameter_list = 107, + sym_type_parameter = 108, + sym_union_type = 109, + sym_type_alias = 110, + sym_variant = 111, + sym_positional_payload = 112, + sym_record_type = 113, + sym_field_declarations = 114, + sym_field_declaration = 115, + sym_type_validation = 116, + sym_effect_declaration = 117, + sym_multiplicity = 118, + sym_operation_declaration = 119, + sym_effect_set = 120, + sym_effect_list = 121, + sym_effect_ref = 122, + sym__type = 123, + sym_function_type = 124, + sym_generic_type = 125, + sym_array_type = 126, + sym_type_identifier = 127, + sym_type_list = 128, + sym_expression_statement = 129, + sym_expression = 130, + sym_match_expression = 131, + sym_match_arm = 132, + sym_if_expression = 133, + sym_handler_expression = 134, + sym_handler_arm = 135, + sym_handler_params = 136, + sym_kernel_expression = 137, + sym_kernel_arm = 138, + sym_select_expression = 139, + sym_select_arm = 140, + sym_ternary_expression = 141, + sym_binary_expression = 142, + sym_unary_expression = 143, + sym_pipe_expression = 144, + sym_call_expression = 145, + sym_argument_list = 146, + sym_named_argument_list = 147, + sym_named_argument = 148, + sym_primary_expression = 149, + sym_spawn_expression = 150, + sym_yield_expression = 151, + sym_await_call = 152, + sym_send_call = 153, + sym_recv_call = 154, + sym_perform_expression = 155, + sym_resume_expression = 156, + sym_type_constructor = 157, + sym_type_arguments = 158, + sym__call_type_arguments = 159, + sym__call_type_list = 160, + sym_update_expression = 161, + sym_field_assignments = 162, + sym_field_assignment = 163, + sym_block = 164, + sym_object_literal = 165, + sym_lambda_expression = 166, + sym_literal = 167, + sym_list_literal = 168, + sym_map_literal = 169, + sym_map_entry = 170, + sym_pattern = 171, + sym_structural_pattern = 172, + sym_tuple_pattern = 173, + sym_list_pattern = 174, + sym_field_pattern = 175, + sym_module_declaration = 176, + sym_signature_ascription = 177, + sym_module_item = 178, + sym_export_declaration = 179, + sym__module_declaration = 180, + sym_signature_declaration = 181, + sym_signature_item = 182, + sym_signature_value = 183, + sym_signature_function = 184, + sym_signature_type = 185, + sym_signature_module = 186, + sym_qualified_path = 187, + sym_symbol_path = 188, + sym_boolean = 189, + sym_doc_comment = 190, + aux_sym_source_file_repeat1 = 191, + aux_sym_legacy_import_path_repeat1 = 192, + aux_sym_import_target_repeat1 = 193, + aux_sym_import_member_list_repeat1 = 194, + aux_sym_extern_parameter_list_repeat1 = 195, + aux_sym_parameter_list_repeat1 = 196, + aux_sym_type_parameter_list_repeat1 = 197, + aux_sym_union_type_repeat1 = 198, + aux_sym_positional_payload_repeat1 = 199, + aux_sym_field_declarations_repeat1 = 200, + aux_sym_effect_declaration_repeat1 = 201, + aux_sym_effect_list_repeat1 = 202, + aux_sym_match_expression_repeat1 = 203, + aux_sym_handler_expression_repeat1 = 204, + aux_sym_handler_params_repeat1 = 205, + aux_sym_kernel_expression_repeat1 = 206, + aux_sym_select_expression_repeat1 = 207, + aux_sym_argument_list_repeat1 = 208, + aux_sym_named_argument_list_repeat1 = 209, + aux_sym__call_type_list_repeat1 = 210, + aux_sym_field_assignments_repeat1 = 211, + aux_sym_map_literal_repeat1 = 212, + aux_sym_pattern_repeat1 = 213, + aux_sym_tuple_pattern_repeat1 = 214, + aux_sym_list_pattern_repeat1 = 215, + aux_sym_field_pattern_repeat1 = 216, + aux_sym_module_declaration_repeat1 = 217, + aux_sym_signature_declaration_repeat1 = 218, + aux_sym_qualified_path_repeat1 = 219, + aux_sym_doc_comment_repeat1 = 220, }; static const char * const ts_symbol_names[] = { @@ -324,6 +325,7 @@ static const char * const ts_symbol_names[] = { [sym_line_comment] = "line_comment", [sym__call_open_gap] = "_call_open_gap", [sym__statement_break] = "_statement_break", + [sym__type_application_ahead] = "_type_application_ahead", [sym_source_file] = "source_file", [sym_statement] = "statement", [sym_import_statement] = "import_statement", @@ -547,6 +549,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_line_comment] = sym_line_comment, [sym__call_open_gap] = sym__call_open_gap, [sym__statement_break] = sym__statement_break, + [sym__type_application_ahead] = sym__type_application_ahead, [sym_source_file] = sym_source_file, [sym_statement] = sym_statement, [sym_import_statement] = sym_import_statement, @@ -1028,6 +1031,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = true, }, + [sym__type_application_ahead] = { + .visible = false, + .named = true, + }, [sym_source_file] = { .visible = true, .named = true, @@ -1704,51 +1711,51 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [30] = {.index = 48, .length = 1}, [31] = {.index = 49, .length = 2}, [32] = {.index = 51, .length = 2}, - [33] = {.index = 53, .length = 1}, - [34] = {.index = 54, .length = 1}, - [35] = {.index = 55, .length = 2}, - [36] = {.index = 57, .length = 2}, - [37] = {.index = 59, .length = 3}, - [38] = {.index = 62, .length = 1}, - [39] = {.index = 63, .length = 2}, - [40] = {.index = 65, .length = 2}, - [41] = {.index = 67, .length = 1}, - [42] = {.index = 68, .length = 2}, - [43] = {.index = 70, .length = 2}, - [44] = {.index = 72, .length = 2}, - [45] = {.index = 74, .length = 3}, - [46] = {.index = 77, .length = 1}, - [47] = {.index = 78, .length = 2}, - [48] = {.index = 80, .length = 3}, - [49] = {.index = 83, .length = 1}, - [50] = {.index = 84, .length = 3}, - [51] = {.index = 87, .length = 3}, - [52] = {.index = 90, .length = 2}, - [53] = {.index = 92, .length = 2}, - [54] = {.index = 94, .length = 3}, - [55] = {.index = 97, .length = 2}, - [56] = {.index = 99, .length = 2}, - [57] = {.index = 101, .length = 4}, - [58] = {.index = 105, .length = 1}, - [59] = {.index = 106, .length = 2}, + [33] = {.index = 53, .length = 2}, + [34] = {.index = 55, .length = 2}, + [35] = {.index = 57, .length = 3}, + [36] = {.index = 60, .length = 1}, + [37] = {.index = 61, .length = 2}, + [38] = {.index = 63, .length = 2}, + [39] = {.index = 65, .length = 1}, + [40] = {.index = 66, .length = 2}, + [41] = {.index = 68, .length = 2}, + [42] = {.index = 70, .length = 2}, + [43] = {.index = 72, .length = 3}, + [44] = {.index = 75, .length = 1}, + [45] = {.index = 76, .length = 2}, + [46] = {.index = 78, .length = 3}, + [47] = {.index = 81, .length = 1}, + [48] = {.index = 82, .length = 3}, + [49] = {.index = 85, .length = 1}, + [50] = {.index = 86, .length = 1}, + [51] = {.index = 87, .length = 1}, + [52] = {.index = 88, .length = 3}, + [53] = {.index = 91, .length = 3}, + [54] = {.index = 94, .length = 2}, + [55] = {.index = 96, .length = 2}, + [56] = {.index = 98, .length = 4}, + [57] = {.index = 102, .length = 1}, + [58] = {.index = 103, .length = 2}, + [59] = {.index = 105, .length = 3}, [60] = {.index = 108, .length = 3}, - [61] = {.index = 111, .length = 3}, - [62] = {.index = 114, .length = 2}, - [63] = {.index = 35, .length = 2}, - [64] = {.index = 116, .length = 3}, - [65] = {.index = 119, .length = 2}, + [61] = {.index = 111, .length = 2}, + [62] = {.index = 35, .length = 2}, + [63] = {.index = 113, .length = 3}, + [64] = {.index = 116, .length = 2}, + [65] = {.index = 118, .length = 3}, [66] = {.index = 121, .length = 3}, - [67] = {.index = 124, .length = 3}, - [68] = {.index = 127, .length = 2}, - [69] = {.index = 129, .length = 2}, - [70] = {.index = 131, .length = 2}, - [71] = {.index = 133, .length = 4}, - [72] = {.index = 137, .length = 2}, - [73] = {.index = 139, .length = 1}, - [74] = {.index = 140, .length = 2}, - [75] = {.index = 142, .length = 2}, - [76] = {.index = 144, .length = 2}, - [77] = {.index = 146, .length = 1}, + [67] = {.index = 124, .length = 2}, + [68] = {.index = 126, .length = 2}, + [69] = {.index = 128, .length = 2}, + [70] = {.index = 130, .length = 4}, + [71] = {.index = 134, .length = 2}, + [72] = {.index = 136, .length = 1}, + [73] = {.index = 137, .length = 2}, + [74] = {.index = 139, .length = 2}, + [75] = {.index = 141, .length = 2}, + [76] = {.index = 143, .length = 2}, + [77] = {.index = 145, .length = 2}, [78] = {.index = 147, .length = 2}, [79] = {.index = 149, .length = 1}, [80] = {.index = 150, .length = 2}, @@ -1774,101 +1781,102 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [100] = {.index = 194, .length = 4}, [101] = {.index = 198, .length = 3}, [102] = {.index = 201, .length = 2}, - [103] = {.index = 203, .length = 4}, - [104] = {.index = 207, .length = 2}, - [105] = {.index = 209, .length = 3}, - [106] = {.index = 212, .length = 3}, - [107] = {.index = 215, .length = 2}, - [108] = {.index = 217, .length = 4}, - [109] = {.index = 221, .length = 1}, - [110] = {.index = 222, .length = 3}, - [111] = {.index = 225, .length = 3}, - [112] = {.index = 228, .length = 4}, - [113] = {.index = 232, .length = 4}, - [114] = {.index = 236, .length = 4}, - [115] = {.index = 240, .length = 3}, - [116] = {.index = 243, .length = 3}, - [117] = {.index = 246, .length = 4}, - [118] = {.index = 246, .length = 4}, - [119] = {.index = 250, .length = 3}, - [120] = {.index = 250, .length = 3}, - [121] = {.index = 253, .length = 3}, - [122] = {.index = 253, .length = 3}, - [123] = {.index = 256, .length = 2}, - [124] = {.index = 258, .length = 2}, - [125] = {.index = 260, .length = 2}, - [126] = {.index = 262, .length = 3}, - [127] = {.index = 265, .length = 1}, - [128] = {.index = 266, .length = 3}, - [129] = {.index = 269, .length = 3}, - [130] = {.index = 272, .length = 3}, - [131] = {.index = 275, .length = 4}, - [132] = {.index = 279, .length = 2}, - [133] = {.index = 281, .length = 3}, - [134] = {.index = 284, .length = 2}, - [135] = {.index = 286, .length = 3}, - [136] = {.index = 289, .length = 4}, - [137] = {.index = 293, .length = 4}, - [138] = {.index = 297, .length = 4}, - [139] = {.index = 301, .length = 4}, - [140] = {.index = 305, .length = 5}, - [141] = {.index = 310, .length = 4}, - [142] = {.index = 310, .length = 4}, - [143] = {.index = 314, .length = 3}, - [144] = {.index = 317, .length = 3}, - [145] = {.index = 320, .length = 2}, - [146] = {.index = 322, .length = 3}, - [147] = {.index = 325, .length = 3}, - [148] = {.index = 328, .length = 3}, - [149] = {.index = 331, .length = 3}, - [150] = {.index = 334, .length = 4}, - [151] = {.index = 338, .length = 4}, - [152] = {.index = 342, .length = 4}, - [153] = {.index = 346, .length = 3}, - [154] = {.index = 349, .length = 3}, - [155] = {.index = 352, .length = 4}, - [156] = {.index = 356, .length = 4}, - [157] = {.index = 360, .length = 4}, - [158] = {.index = 364, .length = 5}, - [159] = {.index = 369, .length = 5}, - [160] = {.index = 374, .length = 3}, - [161] = {.index = 377, .length = 3}, - [162] = {.index = 380, .length = 3}, - [163] = {.index = 383, .length = 4}, - [164] = {.index = 387, .length = 4}, - [165] = {.index = 391, .length = 4}, - [166] = {.index = 395, .length = 4}, - [167] = {.index = 399, .length = 5}, - [168] = {.index = 404, .length = 4}, - [169] = {.index = 408, .length = 5}, - [170] = {.index = 413, .length = 5}, - [171] = {.index = 418, .length = 5}, - [172] = {.index = 423, .length = 3}, - [173] = {.index = 426, .length = 3}, - [174] = {.index = 429, .length = 4}, - [175] = {.index = 433, .length = 4}, - [176] = {.index = 437, .length = 4}, - [177] = {.index = 441, .length = 4}, - [178] = {.index = 445, .length = 4}, - [179] = {.index = 449, .length = 5}, - [180] = {.index = 454, .length = 5}, - [181] = {.index = 459, .length = 5}, - [182] = {.index = 464, .length = 5}, - [183] = {.index = 469, .length = 6}, - [184] = {.index = 475, .length = 3}, - [185] = {.index = 478, .length = 4}, - [186] = {.index = 482, .length = 4}, - [187] = {.index = 486, .length = 5}, - [188] = {.index = 491, .length = 5}, - [189] = {.index = 496, .length = 5}, - [190] = {.index = 501, .length = 6}, - [191] = {.index = 507, .length = 4}, - [192] = {.index = 511, .length = 4}, - [193] = {.index = 515, .length = 5}, - [194] = {.index = 520, .length = 5}, - [195] = {.index = 525, .length = 6}, - [196] = {.index = 531, .length = 5}, - [197] = {.index = 536, .length = 6}, + [103] = {.index = 203, .length = 1}, + [104] = {.index = 204, .length = 4}, + [105] = {.index = 208, .length = 2}, + [106] = {.index = 210, .length = 3}, + [107] = {.index = 213, .length = 3}, + [108] = {.index = 216, .length = 2}, + [109] = {.index = 218, .length = 4}, + [110] = {.index = 222, .length = 1}, + [111] = {.index = 223, .length = 3}, + [112] = {.index = 226, .length = 3}, + [113] = {.index = 229, .length = 4}, + [114] = {.index = 233, .length = 4}, + [115] = {.index = 237, .length = 4}, + [116] = {.index = 241, .length = 3}, + [117] = {.index = 244, .length = 3}, + [118] = {.index = 247, .length = 4}, + [119] = {.index = 247, .length = 4}, + [120] = {.index = 251, .length = 3}, + [121] = {.index = 251, .length = 3}, + [122] = {.index = 254, .length = 3}, + [123] = {.index = 254, .length = 3}, + [124] = {.index = 257, .length = 2}, + [125] = {.index = 259, .length = 2}, + [126] = {.index = 261, .length = 2}, + [127] = {.index = 263, .length = 3}, + [128] = {.index = 266, .length = 1}, + [129] = {.index = 267, .length = 3}, + [130] = {.index = 270, .length = 3}, + [131] = {.index = 273, .length = 3}, + [132] = {.index = 276, .length = 4}, + [133] = {.index = 280, .length = 2}, + [134] = {.index = 282, .length = 3}, + [135] = {.index = 285, .length = 2}, + [136] = {.index = 287, .length = 3}, + [137] = {.index = 290, .length = 4}, + [138] = {.index = 294, .length = 4}, + [139] = {.index = 298, .length = 4}, + [140] = {.index = 302, .length = 4}, + [141] = {.index = 306, .length = 5}, + [142] = {.index = 311, .length = 4}, + [143] = {.index = 311, .length = 4}, + [144] = {.index = 315, .length = 3}, + [145] = {.index = 318, .length = 3}, + [146] = {.index = 321, .length = 2}, + [147] = {.index = 323, .length = 3}, + [148] = {.index = 326, .length = 3}, + [149] = {.index = 329, .length = 3}, + [150] = {.index = 332, .length = 3}, + [151] = {.index = 335, .length = 4}, + [152] = {.index = 339, .length = 4}, + [153] = {.index = 343, .length = 4}, + [154] = {.index = 347, .length = 3}, + [155] = {.index = 350, .length = 3}, + [156] = {.index = 353, .length = 4}, + [157] = {.index = 357, .length = 4}, + [158] = {.index = 361, .length = 4}, + [159] = {.index = 365, .length = 5}, + [160] = {.index = 370, .length = 5}, + [161] = {.index = 375, .length = 3}, + [162] = {.index = 378, .length = 3}, + [163] = {.index = 381, .length = 3}, + [164] = {.index = 384, .length = 4}, + [165] = {.index = 388, .length = 4}, + [166] = {.index = 392, .length = 4}, + [167] = {.index = 396, .length = 4}, + [168] = {.index = 400, .length = 5}, + [169] = {.index = 405, .length = 4}, + [170] = {.index = 409, .length = 5}, + [171] = {.index = 414, .length = 5}, + [172] = {.index = 419, .length = 5}, + [173] = {.index = 424, .length = 3}, + [174] = {.index = 427, .length = 3}, + [175] = {.index = 430, .length = 4}, + [176] = {.index = 434, .length = 4}, + [177] = {.index = 438, .length = 4}, + [178] = {.index = 442, .length = 4}, + [179] = {.index = 446, .length = 4}, + [180] = {.index = 450, .length = 5}, + [181] = {.index = 455, .length = 5}, + [182] = {.index = 460, .length = 5}, + [183] = {.index = 465, .length = 5}, + [184] = {.index = 470, .length = 6}, + [185] = {.index = 476, .length = 3}, + [186] = {.index = 479, .length = 4}, + [187] = {.index = 483, .length = 4}, + [188] = {.index = 487, .length = 5}, + [189] = {.index = 492, .length = 5}, + [190] = {.index = 497, .length = 5}, + [191] = {.index = 502, .length = 6}, + [192] = {.index = 508, .length = 4}, + [193] = {.index = 512, .length = 4}, + [194] = {.index = 516, .length = 5}, + [195] = {.index = 521, .length = 5}, + [196] = {.index = 526, .length = 6}, + [197] = {.index = 532, .length = 5}, + [198] = {.index = 537, .length = 6}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -1958,143 +1966,143 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_callee, 0}, {field_index, 2}, [53] = - {field_variance, 0}, - [54] = - {field_variance, 1, .inherited = true}, - [55] = {field_callee, 0}, {field_type_arguments, 1}, - [57] = + [55] = {field_keyword, 1}, {field_name, 2}, - [59] = + [57] = {field_body, 3}, {field_keyword, 1}, {field_name, 2}, - [62] = + [60] = {field_body, 4}, - [63] = + [61] = {field_name, 1}, {field_variance, 0}, - [65] = + [63] = {field_body, 4}, {field_name, 1}, - [67] = + [65] = {field_name, 2}, - [68] = + [66] = {field_name, 2}, {field_stage, 0}, - [70] = + [68] = {field_body, 2}, {field_operation, 0}, - [72] = + [70] = {field_body, 4}, {field_effect, 1}, - [74] = + [72] = {field_body, 3}, {field_effect, 0}, {field_operation, 1}, - [77] = + [75] = {field_element, 1}, - [78] = + [76] = {field_body, 2}, {field_pattern, 0}, - [80] = + [78] = {field_keyword, 1}, {field_path, 2}, {field_state, 0}, - [83] = + [81] = {field_declaration, 1}, - [84] = + [82] = {field_keyword, 0}, {field_path, 1}, {field_signature, 2}, + [85] = + {field_variance, 0}, + [86] = + {field_variance, 1, .inherited = true}, [87] = + {field_variance, 2, .inherited = true}, + [88] = {field_condition, 0}, {field_else, 4}, {field_then, 2}, - [90] = - {field_variance, 0}, - {field_variance, 2, .inherited = true}, - [92] = - {field_variance, 0, .inherited = true}, - {field_variance, 1, .inherited = true}, - [94] = + [91] = {field_keyword, 1}, {field_name, 2}, {field_value, 4}, - [97] = + [94] = {field_definition, 4}, {field_name, 2}, - [99] = + [96] = {field_keyword, 1}, {field_path, 2}, - [101] = + [98] = {field_keyword, 0}, {field_name, 1}, {field_type, 3}, {field_value, 5}, - [105] = + [102] = {field_body, 5}, - [106] = + [103] = {field_body, 5}, {field_name, 1}, - [108] = + [105] = {field_body, 5}, {field_effects, 4}, {field_name, 1}, - [111] = + [108] = {field_body, 5}, {field_name, 1}, {field_parameters, 3}, - [114] = + [111] = {field_name, 2}, {field_parameters, 4}, - [116] = + [113] = {field_body, 5}, {field_effect, 2}, {field_stage, 1}, - [119] = + [116] = {field_body, 3}, {field_operation, 0}, - [121] = + [118] = {field_body, 5}, {field_effect, 1}, {field_instantiation, 2}, - [124] = + [121] = {field_body, 4}, {field_effect, 0}, {field_operation, 1}, - [127] = + [124] = {field_element, 1}, {field_element, 2, .inherited = true}, - [129] = + [126] = {field_element, 0, .inherited = true}, {field_element, 1, .inherited = true}, - [131] = + [128] = {field_effect, 1}, {field_operation, 3}, - [133] = + [130] = {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, {field_state, 0}, - [137] = + [134] = {field_declaration, 2}, {field_opaque, 1}, - [139] = + [136] = {field_declaration, 2}, - [140] = + [137] = {field_extra, 3}, {field_path, 1}, - [142] = + [139] = {field_path, 1}, {field_signature, 2}, - [144] = + [141] = {field_name, 2}, {field_opaque, 0}, - [146] = - {field_variance, 1}, + [143] = + {field_variance, 0}, + {field_variance, 2, .inherited = true}, + [145] = + {field_variance, 0, .inherited = true}, + {field_variance, 1, .inherited = true}, [147] = {field_body, 5}, {field_name, 2}, @@ -2174,429 +2182,431 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_declaration, 3}, {field_opaque, 2}, [203] = + {field_variance, 1}, + [204] = {field_keyword, 1}, {field_name, 2}, {field_type, 4}, {field_value, 6}, - [207] = + [208] = {field_body, 6}, {field_name, 2}, - [209] = + [210] = {field_body, 6}, {field_effects, 5}, {field_name, 2}, - [212] = + [213] = {field_body, 6}, {field_name, 2}, {field_parameters, 4}, - [215] = + [216] = {field_name, 3}, {field_parameters, 5}, - [217] = + [218] = {field_keyword, 2}, {field_path, 3}, {field_signature, 4}, {field_state, 1}, - [221] = - {field_body, 7}, [222] = {field_body, 7}, + [223] = + {field_body, 7}, {field_name, 1}, {field_type_parameters, 3}, - [225] = + [226] = {field_body, 7}, {field_name, 1}, {field_return_type, 5}, - [228] = + [229] = {field_body, 7}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [232] = + [233] = {field_body, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [236] = + [237] = {field_body, 7}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [240] = + [241] = {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [243] = + [244] = {field_name, 2}, {field_stage, 0}, {field_type_parameters, 4}, - [246] = + [247] = {field_multiplicity, 0}, {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [250] = + [251] = {field_name, 2}, {field_replayable, 1}, {field_type, 4}, - [253] = + [254] = {field_multiplicity, 1}, {field_name, 2}, {field_type, 4}, - [256] = + [257] = {field_element, 1}, {field_rest, 4}, - [258] = + [259] = {field_effects, 4}, {field_name, 1}, - [260] = + [261] = {field_name, 1}, {field_parameters, 3}, - [262] = + [263] = {field_definition, 4}, {field_name, 2}, {field_opaque, 0}, - [265] = - {field_condition, 0}, [266] = + {field_condition, 0}, + [267] = {field_body, 7}, {field_name, 2}, {field_return_type, 6}, - [269] = + [270] = {field_body, 7}, {field_effects, 5}, {field_name, 2}, - [272] = + [273] = {field_body, 7}, {field_name, 2}, {field_parameters, 4}, - [275] = + [276] = {field_body, 7}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [279] = + [280] = {field_name, 3}, {field_return_type, 7}, - [281] = + [282] = {field_definition, 7}, {field_name, 2}, {field_type_parameters, 4}, - [284] = + [285] = {field_name, 2}, {field_type_parameters, 4}, - [286] = + [287] = {field_body, 8}, {field_name, 1}, {field_type_parameters, 3}, - [289] = + [290] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [293] = + [294] = {field_body, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [297] = + [298] = {field_body, 8}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [301] = + [302] = {field_body, 8}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [305] = + [306] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [310] = + [311] = {field_multiplicity, 1}, {field_name, 3}, {field_replayable, 2}, {field_type, 5}, - [314] = + [315] = {field_alternative, 7}, {field_condition, 1}, {field_consequence, 3}, - [317] = + [318] = {field_element, 1}, {field_element, 2, .inherited = true}, {field_rest, 5}, - [320] = + [321] = {field_name, 1}, {field_return_type, 5}, - [322] = + [323] = {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [325] = + [326] = {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [328] = + [329] = {field_body, 8}, {field_name, 2}, {field_type_parameters, 4}, - [331] = + [332] = {field_body, 8}, {field_name, 2}, {field_return_type, 6}, - [334] = + [335] = {field_body, 8}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [338] = + [339] = {field_body, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [342] = + [343] = {field_body, 8}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [346] = + [347] = {field_name, 3}, {field_parameters, 5}, {field_return_type, 8}, - [349] = + [350] = {field_name, 3}, {field_stage, 1}, {field_type_parameters, 5}, - [352] = + [353] = {field_body, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [356] = + [357] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [360] = + [361] = {field_body, 9}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [364] = + [365] = {field_body, 9}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [369] = + [370] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [374] = + [375] = {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [377] = + [378] = {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [380] = + [381] = {field_body, 9}, {field_name, 2}, {field_type_parameters, 4}, - [383] = + [384] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [387] = + [388] = {field_body, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [391] = + [392] = {field_body, 9}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [395] = + [396] = {field_body, 9}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [399] = + [400] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [404] = + [405] = {field_body, 10}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [408] = + [409] = {field_body, 10}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [413] = + [414] = {field_body, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [418] = + [419] = {field_body, 10}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [423] = + [424] = {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [426] = + [427] = {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [429] = + [430] = {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [433] = + [434] = {field_definition, 7}, {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [437] = + [438] = {field_body, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [441] = + [442] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [445] = + [446] = {field_body, 10}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [449] = + [450] = {field_body, 10}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [454] = + [455] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [459] = + [460] = {field_body, 11}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [464] = + [465] = {field_body, 11}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [469] = + [470] = {field_body, 11}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [475] = + [476] = {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [478] = + [479] = {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [482] = + [483] = {field_body, 11}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [486] = + [487] = {field_body, 11}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [491] = + [492] = {field_body, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [496] = + [497] = {field_body, 11}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [501] = + [502] = {field_body, 12}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [507] = + [508] = {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [511] = + [512] = {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [515] = + [516] = {field_body, 12}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [520] = + [521] = {field_body, 12}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [525] = + [526] = {field_body, 12}, {field_effects, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [531] = + [532] = {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [536] = + [537] = {field_body, 13}, {field_effects, 11}, {field_name, 2}, @@ -2607,7 +2617,7 @@ static const TSFieldMapEntry ts_field_map_entries[] = { static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { [0] = {0}, - [63] = { + [62] = { [0] = sym_identifier, }, [92] = { @@ -2619,16 +2629,16 @@ static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE [96] = { [1] = sym_identifier, }, - [117] = { + [118] = { [2] = sym_identifier, }, - [119] = { + [120] = { [2] = sym_identifier, }, - [121] = { + [122] = { [2] = sym_identifier, }, - [141] = { + [142] = { [3] = sym_identifier, }, }; @@ -3168,132 +3178,132 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [524] = 284, [525] = 293, [526] = 261, - [527] = 337, - [528] = 528, - [529] = 329, - [530] = 313, - [531] = 302, - [532] = 314, - [533] = 309, - [534] = 534, - [535] = 535, - [536] = 315, - [537] = 316, - [538] = 308, - [539] = 539, - [540] = 317, + [527] = 527, + [528] = 328, + [529] = 529, + [530] = 530, + [531] = 329, + [532] = 313, + [533] = 302, + [534] = 314, + [535] = 309, + [536] = 536, + [537] = 537, + [538] = 315, + [539] = 316, + [540] = 308, [541] = 541, - [542] = 310, - [543] = 543, - [544] = 318, - [545] = 545, - [546] = 546, + [542] = 542, + [543] = 317, + [544] = 544, + [545] = 310, + [546] = 318, [547] = 547, [548] = 548, [549] = 549, - [550] = 539, + [550] = 550, [551] = 551, - [552] = 545, - [553] = 553, - [554] = 554, - [555] = 546, - [556] = 554, - [557] = 319, - [558] = 553, - [559] = 559, - [560] = 297, - [561] = 331, - [562] = 562, - [563] = 549, - [564] = 543, - [565] = 307, + [552] = 541, + [553] = 529, + [554] = 547, + [555] = 555, + [556] = 548, + [557] = 557, + [558] = 557, + [559] = 319, + [560] = 555, + [561] = 561, + [562] = 551, + [563] = 297, + [564] = 331, + [565] = 527, [566] = 566, - [567] = 567, - [568] = 547, - [569] = 298, - [570] = 301, - [571] = 543, - [572] = 321, - [573] = 548, - [574] = 322, - [575] = 545, - [576] = 546, - [577] = 547, - [578] = 548, - [579] = 323, - [580] = 539, - [581] = 551, - [582] = 320, - [583] = 553, - [584] = 554, - [585] = 324, - [586] = 549, - [587] = 566, - [588] = 311, - [589] = 312, - [590] = 325, - [591] = 326, - [592] = 354, - [593] = 306, - [594] = 594, - [595] = 595, - [596] = 299, - [597] = 300, + [567] = 542, + [568] = 568, + [569] = 569, + [570] = 549, + [571] = 307, + [572] = 301, + [573] = 542, + [574] = 550, + [575] = 547, + [576] = 548, + [577] = 549, + [578] = 550, + [579] = 321, + [580] = 541, + [581] = 529, + [582] = 322, + [583] = 555, + [584] = 557, + [585] = 551, + [586] = 566, + [587] = 323, + [588] = 320, + [589] = 324, + [590] = 311, + [591] = 354, + [592] = 337, + [593] = 312, + [594] = 325, + [595] = 326, + [596] = 596, + [597] = 299, [598] = 598, - [599] = 566, - [600] = 327, - [601] = 328, - [602] = 567, - [603] = 562, - [604] = 567, - [605] = 562, + [599] = 300, + [600] = 566, + [601] = 569, + [602] = 306, + [603] = 603, + [604] = 569, + [605] = 527, [606] = 303, [607] = 304, - [608] = 305, - [609] = 551, - [610] = 610, + [608] = 327, + [609] = 305, + [610] = 298, [611] = 611, [612] = 612, [613] = 613, [614] = 614, - [615] = 614, + [615] = 611, [616] = 616, [617] = 617, - [618] = 618, + [618] = 614, [619] = 616, [620] = 614, [621] = 621, [622] = 622, - [623] = 623, - [624] = 613, - [625] = 616, - [626] = 613, + [623] = 616, + [624] = 624, + [625] = 625, + [626] = 611, [627] = 627, - [628] = 628, + [628] = 231, [629] = 629, [630] = 630, [631] = 631, [632] = 632, - [633] = 633, + [633] = 239, [634] = 634, [635] = 635, [636] = 636, - [637] = 636, + [637] = 637, [638] = 638, - [639] = 635, + [639] = 639, [640] = 640, - [641] = 638, + [641] = 232, [642] = 642, - [643] = 640, - [644] = 644, - [645] = 645, - [646] = 646, + [643] = 638, + [644] = 639, + [645] = 637, + [646] = 640, [647] = 647, [648] = 648, - [649] = 437, + [649] = 649, [650] = 650, - [651] = 231, - [652] = 232, + [651] = 437, + [652] = 652, [653] = 653, [654] = 654, [655] = 655, @@ -3309,7 +3319,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [665] = 665, [666] = 666, [667] = 667, - [668] = 667, + [668] = 665, [669] = 669, [670] = 670, [671] = 671, @@ -3327,9 +3337,9 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [683] = 683, [684] = 684, [685] = 675, - [686] = 239, - [687] = 684, - [688] = 661, + [686] = 686, + [687] = 661, + [688] = 686, [689] = 689, [690] = 690, [691] = 691, @@ -3393,11 +3403,11 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [749] = 749, [750] = 750, [751] = 751, - [752] = 752, - [753] = 284, - [754] = 258, + [752] = 284, + [753] = 258, + [754] = 518, [755] = 755, - [756] = 518, + [756] = 756, [757] = 757, [758] = 758, [759] = 759, @@ -3405,7 +3415,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [761] = 761, [762] = 762, [763] = 763, - [764] = 231, + [764] = 764, [765] = 765, [766] = 766, [767] = 767, @@ -3415,69 +3425,69 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [771] = 771, [772] = 772, [773] = 773, - [774] = 232, - [775] = 231, + [774] = 762, + [775] = 775, [776] = 776, - [777] = 777, - [778] = 760, + [777] = 760, + [778] = 764, [779] = 779, - [780] = 780, - [781] = 765, - [782] = 782, - [783] = 783, + [780] = 776, + [781] = 781, + [782] = 771, + [783] = 772, [784] = 784, - [785] = 783, - [786] = 773, - [787] = 779, - [788] = 772, - [789] = 761, - [790] = 790, - [791] = 780, - [792] = 762, - [793] = 766, - [794] = 768, - [795] = 770, - [796] = 771, - [797] = 784, + [785] = 773, + [786] = 786, + [787] = 787, + [788] = 761, + [789] = 763, + [790] = 766, + [791] = 767, + [792] = 769, + [793] = 770, + [794] = 775, + [795] = 781, + [796] = 796, + [797] = 797, [798] = 798, - [799] = 799, - [800] = 800, - [801] = 777, - [802] = 776, + [799] = 786, + [800] = 617, + [801] = 625, + [802] = 802, [803] = 803, [804] = 804, [805] = 805, - [806] = 239, + [806] = 806, [807] = 807, - [808] = 239, - [809] = 621, + [808] = 624, + [809] = 809, [810] = 810, - [811] = 811, + [811] = 621, [812] = 812, - [813] = 618, - [814] = 814, - [815] = 815, - [816] = 816, - [817] = 617, - [818] = 811, - [819] = 611, + [813] = 802, + [814] = 807, + [815] = 802, + [816] = 807, + [817] = 622, + [818] = 818, + [819] = 819, [820] = 820, - [821] = 811, - [822] = 820, - [823] = 612, - [824] = 820, + [821] = 821, + [822] = 822, + [823] = 823, + [824] = 822, [825] = 825, [826] = 826, - [827] = 232, + [827] = 823, [828] = 828, [829] = 829, - [830] = 830, - [831] = 831, - [832] = 830, - [833] = 825, + [830] = 828, + [831] = 823, + [832] = 832, + [833] = 833, [834] = 834, - [835] = 828, - [836] = 830, + [835] = 835, + [836] = 836, [837] = 837, [838] = 838, [839] = 839, @@ -3486,37 +3496,37 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [842] = 842, [843] = 843, [844] = 844, - [845] = 841, + [845] = 845, [846] = 846, [847] = 847, - [848] = 848, - [849] = 849, + [848] = 613, + [849] = 834, [850] = 850, [851] = 851, [852] = 852, [853] = 853, [854] = 854, - [855] = 855, + [855] = 853, [856] = 856, - [857] = 857, + [857] = 232, [858] = 858, - [859] = 858, + [859] = 231, [860] = 860, [861] = 861, - [862] = 232, + [862] = 862, [863] = 863, - [864] = 231, + [864] = 864, [865] = 865, [866] = 866, [867] = 867, [868] = 868, [869] = 869, - [870] = 870, + [870] = 850, [871] = 871, [872] = 872, [873] = 873, [874] = 874, - [875] = 852, + [875] = 875, [876] = 876, [877] = 877, [878] = 878, @@ -3527,20 +3537,20 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [883] = 883, [884] = 884, [885] = 885, - [886] = 886, + [886] = 842, [887] = 887, - [888] = 854, - [889] = 889, + [888] = 888, + [889] = 879, [890] = 890, - [891] = 891, - [892] = 892, + [891] = 882, + [892] = 852, [893] = 893, - [894] = 880, + [894] = 894, [895] = 895, [896] = 896, [897] = 897, [898] = 898, - [899] = 857, + [899] = 899, [900] = 900, [901] = 901, [902] = 902, @@ -3549,47 +3559,47 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [905] = 905, [906] = 906, [907] = 907, - [908] = 908, + [908] = 905, [909] = 909, - [910] = 910, + [910] = 880, [911] = 911, - [912] = 912, - [913] = 913, - [914] = 914, - [915] = 874, - [916] = 916, - [917] = 858, - [918] = 855, - [919] = 877, - [920] = 902, - [921] = 903, - [922] = 623, - [923] = 850, - [924] = 853, - [925] = 913, + [912] = 850, + [913] = 842, + [914] = 868, + [915] = 881, + [916] = 895, + [917] = 917, + [918] = 871, + [919] = 854, + [920] = 920, + [921] = 836, + [922] = 856, + [923] = 867, + [924] = 878, + [925] = 880, [926] = 926, - [927] = 842, - [928] = 860, - [929] = 873, - [930] = 887, + [927] = 927, + [928] = 834, + [929] = 881, + [930] = 853, [931] = 931, - [932] = 874, - [933] = 841, - [934] = 855, - [935] = 902, - [936] = 926, - [937] = 896, - [938] = 852, + [932] = 920, + [933] = 909, + [934] = 706, + [935] = 239, + [936] = 631, + [937] = 937, + [938] = 938, [939] = 939, - [940] = 239, - [941] = 706, - [942] = 632, + [940] = 940, + [941] = 941, + [942] = 942, [943] = 943, [944] = 944, - [945] = 631, + [945] = 945, [946] = 946, [947] = 947, - [948] = 948, + [948] = 937, [949] = 949, [950] = 950, [951] = 951, @@ -3597,178 +3607,178 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [953] = 953, [954] = 954, [955] = 955, - [956] = 955, + [956] = 636, [957] = 957, - [958] = 958, - [959] = 959, + [958] = 946, + [959] = 937, [960] = 960, [961] = 961, [962] = 962, - [963] = 963, + [963] = 946, [964] = 964, - [965] = 953, + [965] = 965, [966] = 966, - [967] = 955, + [967] = 967, [968] = 968, - [969] = 953, + [969] = 885, [970] = 970, [971] = 971, [972] = 972, - [973] = 973, + [973] = 972, [974] = 974, - [975] = 975, - [976] = 976, - [977] = 974, - [978] = 807, - [979] = 976, - [980] = 884, + [975] = 967, + [976] = 968, + [977] = 970, + [978] = 978, + [979] = 971, + [980] = 966, [981] = 981, - [982] = 981, - [983] = 983, - [984] = 437, - [985] = 973, - [986] = 986, + [982] = 982, + [983] = 437, + [984] = 818, + [985] = 978, + [986] = 981, [987] = 987, - [988] = 975, - [989] = 987, - [990] = 986, + [988] = 988, + [989] = 989, + [990] = 990, [991] = 991, - [992] = 972, + [992] = 992, [993] = 993, [994] = 994, [995] = 995, [996] = 996, [997] = 997, - [998] = 998, + [998] = 647, [999] = 999, [1000] = 1000, [1001] = 1001, - [1002] = 1002, - [1003] = 997, + [1002] = 987, + [1003] = 1003, [1004] = 1004, [1005] = 1005, [1006] = 1006, [1007] = 1007, - [1008] = 1008, - [1009] = 644, + [1008] = 1003, + [1009] = 1009, [1010] = 1010, [1011] = 1011, [1012] = 1012, - [1013] = 1012, - [1014] = 1014, + [1013] = 1013, + [1014] = 1013, [1015] = 1015, [1016] = 1016, - [1017] = 1016, - [1018] = 1018, - [1019] = 1019, + [1017] = 1017, + [1018] = 996, + [1019] = 1005, [1020] = 1020, - [1021] = 1021, + [1021] = 1020, [1022] = 1022, - [1023] = 998, - [1024] = 1004, - [1025] = 1025, - [1026] = 1025, - [1027] = 997, - [1028] = 1028, - [1029] = 1001, - [1030] = 1002, - [1031] = 1006, - [1032] = 993, + [1023] = 992, + [1024] = 1000, + [1025] = 1000, + [1026] = 1001, + [1027] = 1011, + [1028] = 797, + [1029] = 1006, + [1030] = 1030, + [1031] = 989, + [1032] = 1015, [1033] = 1033, - [1034] = 1001, - [1035] = 1018, - [1036] = 1011, + [1034] = 1034, + [1035] = 1030, + [1036] = 798, [1037] = 1037, - [1038] = 1021, - [1039] = 799, - [1040] = 1006, - [1041] = 1002, - [1042] = 1028, + [1038] = 1034, + [1039] = 1001, + [1040] = 995, + [1041] = 1033, + [1042] = 993, [1043] = 1043, - [1044] = 1043, - [1045] = 1000, - [1046] = 995, - [1047] = 1047, - [1048] = 1014, - [1049] = 1020, - [1050] = 1050, - [1051] = 1018, - [1052] = 1011, - [1053] = 1015, - [1054] = 1021, - [1055] = 1055, - [1056] = 1043, - [1057] = 1022, - [1058] = 800, - [1059] = 1050, - [1060] = 1007, - [1061] = 1019, - [1062] = 1062, - [1063] = 1005, - [1064] = 1008, + [1044] = 1012, + [1045] = 1030, + [1046] = 989, + [1047] = 1015, + [1048] = 1034, + [1049] = 1016, + [1050] = 994, + [1051] = 992, + [1052] = 1052, + [1053] = 997, + [1054] = 1054, + [1055] = 1017, + [1056] = 1007, + [1057] = 1057, + [1058] = 990, + [1059] = 1004, + [1060] = 1010, + [1061] = 1007, + [1062] = 1052, + [1063] = 1037, + [1064] = 1006, [1065] = 1065, - [1066] = 1019, - [1067] = 1067, - [1068] = 1055, - [1069] = 999, - [1070] = 1065, + [1066] = 1066, + [1067] = 261, + [1068] = 1068, + [1069] = 649, + [1070] = 1070, [1071] = 1071, - [1072] = 645, + [1072] = 1072, [1073] = 1073, [1074] = 1074, [1075] = 1075, [1076] = 1076, - [1077] = 1077, - [1078] = 1078, + [1077] = 648, + [1078] = 518, [1079] = 1079, [1080] = 1080, [1081] = 1081, [1082] = 1082, [1083] = 1083, - [1084] = 1080, - [1085] = 892, + [1084] = 1081, + [1085] = 1085, [1086] = 1086, [1087] = 1087, [1088] = 1088, - [1089] = 1089, + [1089] = 1085, [1090] = 1090, [1091] = 1091, [1092] = 1092, [1093] = 1093, [1094] = 1094, - [1095] = 518, - [1096] = 1096, - [1097] = 1097, + [1095] = 1095, + [1096] = 1068, + [1097] = 835, [1098] = 1098, [1099] = 1099, - [1100] = 1089, + [1100] = 1088, [1101] = 1101, - [1102] = 1086, + [1102] = 1081, [1103] = 1103, [1104] = 1104, [1105] = 1105, - [1106] = 1089, + [1106] = 650, [1107] = 1107, [1108] = 1108, [1109] = 1109, - [1110] = 1103, + [1110] = 1110, [1111] = 1111, [1112] = 1112, - [1113] = 646, + [1113] = 1103, [1114] = 1114, [1115] = 1115, - [1116] = 647, - [1117] = 261, + [1116] = 1116, + [1117] = 1117, [1118] = 1118, [1119] = 1119, - [1120] = 1104, + [1120] = 1120, [1121] = 1121, [1122] = 1122, [1123] = 1123, [1124] = 1124, [1125] = 1125, [1126] = 1126, - [1127] = 657, + [1127] = 1127, [1128] = 1128, [1129] = 1129, [1130] = 1130, @@ -3777,148 +3787,148 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1133] = 1133, [1134] = 1134, [1135] = 1135, - [1136] = 1136, + [1136] = 1116, [1137] = 1137, - [1138] = 1133, - [1139] = 1139, + [1138] = 1138, + [1139] = 657, [1140] = 1140, - [1141] = 1141, - [1142] = 653, - [1143] = 1122, + [1141] = 656, + [1142] = 1142, + [1143] = 1143, [1144] = 1144, [1145] = 1145, [1146] = 1146, - [1147] = 1147, + [1147] = 1123, [1148] = 1148, [1149] = 1149, [1150] = 1150, [1151] = 1151, [1152] = 1152, - [1153] = 1126, + [1153] = 1153, [1154] = 1154, - [1155] = 1155, + [1155] = 1130, [1156] = 1156, [1157] = 1157, - [1158] = 1158, - [1159] = 1159, + [1158] = 655, + [1159] = 1154, [1160] = 1160, [1161] = 1161, [1162] = 1162, - [1163] = 1163, + [1163] = 658, [1164] = 1164, - [1165] = 1165, + [1165] = 1149, [1166] = 1166, - [1167] = 1167, - [1168] = 1168, + [1167] = 1156, + [1168] = 1161, [1169] = 1169, - [1170] = 648, - [1171] = 1136, - [1172] = 654, - [1173] = 1173, + [1170] = 1132, + [1171] = 1125, + [1172] = 1172, + [1173] = 652, [1174] = 1174, - [1175] = 1175, - [1176] = 1173, - [1177] = 1149, - [1178] = 1155, - [1179] = 1179, + [1175] = 1152, + [1176] = 1176, + [1177] = 1115, + [1178] = 1123, + [1179] = 1134, [1180] = 1180, [1181] = 1181, [1182] = 1182, - [1183] = 1183, + [1183] = 1126, [1184] = 1184, - [1185] = 1159, + [1185] = 1185, [1186] = 1186, [1187] = 1187, [1188] = 1188, - [1189] = 1160, + [1189] = 1189, [1190] = 1190, [1191] = 1191, [1192] = 1192, - [1193] = 1193, + [1193] = 1135, [1194] = 1194, [1195] = 1195, - [1196] = 1158, - [1197] = 1169, - [1198] = 1183, - [1199] = 1148, + [1196] = 1196, + [1197] = 1197, + [1198] = 1198, + [1199] = 1182, [1200] = 1200, - [1201] = 1188, - [1202] = 650, + [1201] = 1201, + [1202] = 1202, [1203] = 1203, - [1204] = 1165, - [1205] = 1205, - [1206] = 655, - [1207] = 1193, - [1208] = 1208, - [1209] = 1209, - [1210] = 1129, + [1204] = 1176, + [1205] = 1189, + [1206] = 1206, + [1207] = 1180, + [1208] = 1149, + [1209] = 1154, + [1210] = 1210, [1211] = 1211, - [1212] = 656, - [1213] = 1213, + [1212] = 1212, + [1213] = 1129, [1214] = 1214, - [1215] = 1165, - [1216] = 1216, - [1217] = 1133, - [1218] = 1187, - [1219] = 1216, - [1220] = 1182, + [1215] = 1215, + [1216] = 1130, + [1217] = 1161, + [1218] = 1218, + [1219] = 1125, + [1220] = 1148, [1221] = 1221, - [1222] = 1222, - [1223] = 1174, - [1224] = 1224, - [1225] = 1149, - [1226] = 1146, + [1222] = 1176, + [1223] = 1223, + [1224] = 1134, + [1225] = 1160, + [1226] = 1126, [1227] = 1227, - [1228] = 1182, - [1229] = 1155, - [1230] = 1159, + [1228] = 1162, + [1229] = 654, + [1230] = 1206, [1231] = 1231, - [1232] = 1160, + [1232] = 1232, [1233] = 1233, - [1234] = 1205, - [1235] = 1235, - [1236] = 1236, - [1237] = 1237, + [1234] = 1234, + [1235] = 1181, + [1236] = 1201, + [1237] = 1190, [1238] = 1238, - [1239] = 1239, - [1240] = 1240, - [1241] = 1227, + [1239] = 1132, + [1240] = 653, + [1241] = 1181, [1242] = 1242, - [1243] = 1243, + [1243] = 1194, [1244] = 1244, - [1245] = 1136, - [1246] = 1186, - [1247] = 1227, + [1245] = 1245, + [1246] = 1153, + [1247] = 1122, [1248] = 1248, - [1249] = 1237, - [1250] = 1250, - [1251] = 1235, - [1252] = 1130, - [1253] = 1192, - [1254] = 1129, - [1255] = 1152, - [1256] = 1222, - [1257] = 1167, - [1258] = 1258, - [1259] = 1141, - [1260] = 1130, - [1261] = 1147, + [1249] = 1124, + [1250] = 1144, + [1251] = 1251, + [1252] = 1252, + [1253] = 1138, + [1254] = 1153, + [1255] = 1127, + [1256] = 1157, + [1257] = 1242, + [1258] = 1223, + [1259] = 1259, + [1260] = 1169, + [1261] = 1261, [1262] = 1262, [1263] = 1263, - [1264] = 1179, - [1265] = 1123, - [1266] = 1266, - [1267] = 1125, + [1264] = 1264, + [1265] = 1265, + [1266] = 1120, + [1267] = 1267, [1268] = 1268, - [1269] = 1174, + [1269] = 662, [1270] = 1270, [1271] = 1271, - [1272] = 662, - [1273] = 1273, - [1274] = 659, - [1275] = 1275, + [1272] = 1272, + [1273] = 684, + [1274] = 1274, + [1275] = 670, [1276] = 1276, - [1277] = 670, + [1277] = 1277, [1278] = 1278, [1279] = 1279, [1280] = 1280, @@ -3930,107 +3940,107 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1286] = 1286, [1287] = 1287, [1288] = 1288, - [1289] = 1278, - [1290] = 1290, + [1289] = 1289, + [1290] = 1276, [1291] = 1291, [1292] = 1292, [1293] = 1293, [1294] = 1294, [1295] = 1295, [1296] = 1296, - [1297] = 1287, + [1297] = 1297, [1298] = 1298, [1299] = 1299, [1300] = 1300, [1301] = 1301, - [1302] = 1302, - [1303] = 1303, - [1304] = 674, - [1305] = 1305, - [1306] = 617, - [1307] = 618, - [1308] = 621, - [1309] = 1309, - [1310] = 879, + [1302] = 674, + [1303] = 622, + [1304] = 624, + [1305] = 625, + [1306] = 1285, + [1307] = 1307, + [1308] = 1308, + [1309] = 877, + [1310] = 1310, [1311] = 1311, [1312] = 1312, - [1313] = 1313, - [1314] = 611, - [1315] = 1290, + [1313] = 617, + [1314] = 1287, + [1315] = 825, [1316] = 1316, - [1317] = 838, - [1318] = 1318, - [1319] = 612, - [1320] = 1290, + [1317] = 1317, + [1318] = 621, + [1319] = 1319, + [1320] = 1293, [1321] = 1321, [1322] = 1322, - [1323] = 1295, + [1323] = 1323, [1324] = 1324, - [1325] = 1325, - [1326] = 1293, - [1327] = 1327, - [1328] = 1294, - [1329] = 886, - [1330] = 1316, + [1325] = 1291, + [1326] = 1326, + [1327] = 1322, + [1328] = 1328, + [1329] = 876, + [1330] = 1292, [1331] = 1331, [1332] = 1332, - [1333] = 1333, - [1334] = 665, + [1333] = 666, + [1334] = 1334, [1335] = 1335, - [1336] = 1336, - [1337] = 666, - [1338] = 1338, - [1339] = 1332, + [1336] = 667, + [1337] = 1337, + [1338] = 1331, + [1339] = 1339, [1340] = 1340, [1341] = 1341, - [1342] = 1342, - [1343] = 1270, - [1344] = 1336, - [1345] = 1345, - [1346] = 1331, + [1342] = 1334, + [1343] = 1343, + [1344] = 1316, + [1345] = 1340, + [1346] = 1264, [1347] = 1347, - [1348] = 1341, - [1349] = 1349, - [1350] = 1350, - [1351] = 1351, - [1352] = 1350, - [1353] = 1303, + [1348] = 1328, + [1349] = 1265, + [1350] = 1308, + [1351] = 1267, + [1352] = 1310, + [1353] = 1286, [1354] = 1354, - [1355] = 1309, - [1356] = 1283, - [1357] = 1354, - [1358] = 1327, - [1359] = 1333, - [1360] = 1354, - [1361] = 1295, + [1355] = 1326, + [1356] = 1332, + [1357] = 1267, + [1358] = 1293, + [1359] = 1316, + [1360] = 1360, + [1361] = 1264, [1362] = 1362, - [1363] = 1363, - [1364] = 1342, - [1365] = 1180, - [1366] = 1270, + [1363] = 1287, + [1364] = 1364, + [1365] = 673, + [1366] = 1366, [1367] = 1367, - [1368] = 1342, + [1368] = 1368, [1369] = 1369, [1370] = 1370, [1371] = 1371, [1372] = 1372, [1373] = 1373, - [1374] = 690, + [1374] = 1374, [1375] = 1375, [1376] = 1376, - [1377] = 671, + [1377] = 1377, [1378] = 1378, [1379] = 1379, - [1380] = 1380, + [1380] = 690, [1381] = 1381, [1382] = 1382, - [1383] = 701, + [1383] = 740, [1384] = 1384, [1385] = 1385, [1386] = 1386, - [1387] = 740, + [1387] = 1387, [1388] = 1388, - [1389] = 1389, + [1389] = 701, [1390] = 1390, [1391] = 1391, [1392] = 1392, @@ -4038,370 +4048,363 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1394] = 1394, [1395] = 1395, [1396] = 1396, - [1397] = 672, + [1397] = 1397, [1398] = 1398, [1399] = 1399, [1400] = 1400, [1401] = 1401, - [1402] = 1402, - [1403] = 1378, + [1402] = 671, + [1403] = 1403, [1404] = 1404, - [1405] = 1405, - [1406] = 746, - [1407] = 693, + [1405] = 747, + [1406] = 1406, + [1407] = 1407, [1408] = 1408, - [1409] = 725, - [1410] = 702, - [1411] = 727, - [1412] = 1408, - [1413] = 1413, - [1414] = 1414, + [1409] = 1409, + [1410] = 1410, + [1411] = 1411, + [1412] = 1412, + [1413] = 1407, + [1414] = 725, [1415] = 1415, [1416] = 1416, [1417] = 1417, - [1418] = 1418, - [1419] = 703, - [1420] = 694, - [1421] = 695, + [1418] = 702, + [1419] = 672, + [1420] = 1420, + [1421] = 1421, [1422] = 1422, - [1423] = 676, - [1424] = 1424, - [1425] = 1425, + [1423] = 703, + [1424] = 691, + [1425] = 693, [1426] = 1426, - [1427] = 707, - [1428] = 708, - [1429] = 696, - [1430] = 1401, + [1427] = 1427, + [1428] = 1428, + [1429] = 676, + [1430] = 1430, [1431] = 1431, - [1432] = 1432, - [1433] = 692, - [1434] = 691, - [1435] = 1435, - [1436] = 709, - [1437] = 1437, - [1438] = 1422, - [1439] = 1414, - [1440] = 1440, - [1441] = 1405, - [1442] = 1442, - [1443] = 1375, - [1444] = 710, - [1445] = 1415, - [1446] = 1416, + [1432] = 1409, + [1433] = 1433, + [1434] = 707, + [1435] = 1400, + [1436] = 663, + [1437] = 1372, + [1438] = 1399, + [1439] = 694, + [1440] = 708, + [1441] = 1441, + [1442] = 709, + [1443] = 695, + [1444] = 1410, + [1445] = 1445, + [1446] = 1411, [1447] = 1447, - [1448] = 712, - [1449] = 663, - [1450] = 1450, - [1451] = 1451, + [1448] = 711, + [1449] = 1449, + [1450] = 1388, + [1451] = 696, [1452] = 1452, - [1453] = 1453, + [1453] = 713, [1454] = 1454, - [1455] = 1382, - [1456] = 713, + [1455] = 1396, + [1456] = 1364, [1457] = 1457, - [1458] = 715, - [1459] = 1459, - [1460] = 716, - [1461] = 677, + [1458] = 1458, + [1459] = 714, + [1460] = 1460, + [1461] = 715, [1462] = 1462, - [1463] = 1463, - [1464] = 1464, + [1463] = 716, + [1464] = 677, [1465] = 1465, [1466] = 1466, [1467] = 1467, - [1468] = 734, + [1468] = 1468, [1469] = 1469, - [1470] = 1470, + [1470] = 733, [1471] = 1471, - [1472] = 678, - [1473] = 1473, - [1474] = 1417, - [1475] = 1475, + [1472] = 1472, + [1473] = 1412, + [1474] = 1474, + [1475] = 678, [1476] = 1476, [1477] = 1477, [1478] = 1478, - [1479] = 697, + [1479] = 1479, [1480] = 1480, [1481] = 1481, - [1482] = 1450, + [1482] = 1482, [1483] = 1483, [1484] = 1484, [1485] = 1485, - [1486] = 722, + [1486] = 1486, [1487] = 1487, [1488] = 664, - [1489] = 1489, - [1490] = 719, + [1489] = 718, + [1490] = 1490, [1491] = 1491, [1492] = 1492, [1493] = 1493, [1494] = 1494, - [1495] = 700, + [1495] = 1481, [1496] = 1496, - [1497] = 720, - [1498] = 721, + [1497] = 719, + [1498] = 700, [1499] = 1499, - [1500] = 1465, + [1500] = 1500, [1501] = 1501, [1502] = 1502, [1503] = 704, - [1504] = 1504, - [1505] = 660, + [1504] = 720, + [1505] = 721, [1506] = 1506, - [1507] = 679, - [1508] = 1508, - [1509] = 723, + [1507] = 1507, + [1508] = 697, + [1509] = 1379, [1510] = 1510, - [1511] = 1511, - [1512] = 1512, - [1513] = 724, - [1514] = 1372, + [1511] = 679, + [1512] = 1445, + [1513] = 723, + [1514] = 1368, [1515] = 1515, [1516] = 1516, [1517] = 1517, - [1518] = 759, - [1519] = 1373, - [1520] = 1520, - [1521] = 1426, - [1522] = 698, - [1523] = 1373, - [1524] = 1389, - [1525] = 1390, - [1526] = 1391, - [1527] = 1392, - [1528] = 1396, - [1529] = 1496, - [1530] = 699, - [1531] = 726, - [1532] = 1414, - [1533] = 1415, - [1534] = 1416, - [1535] = 1426, - [1536] = 1389, - [1537] = 1435, - [1538] = 705, - [1539] = 1422, - [1540] = 680, - [1541] = 1382, - [1542] = 1542, - [1543] = 1543, - [1544] = 1465, - [1545] = 1545, + [1518] = 1518, + [1519] = 1384, + [1520] = 1385, + [1521] = 1386, + [1522] = 1387, + [1523] = 1391, + [1524] = 724, + [1525] = 1421, + [1526] = 660, + [1527] = 1409, + [1528] = 1410, + [1529] = 1411, + [1530] = 1421, + [1531] = 1368, + [1532] = 1430, + [1533] = 759, + [1534] = 1433, + [1535] = 1535, + [1536] = 1388, + [1537] = 1537, + [1538] = 1538, + [1539] = 1481, + [1540] = 705, + [1541] = 1384, + [1542] = 1481, + [1543] = 726, + [1544] = 1481, + [1545] = 1428, [1546] = 1546, - [1547] = 1465, - [1548] = 1402, - [1549] = 1465, - [1550] = 1465, - [1551] = 1465, - [1552] = 1384, + [1547] = 659, + [1548] = 680, + [1549] = 1549, + [1550] = 698, + [1551] = 1452, + [1552] = 699, [1553] = 1553, [1554] = 1554, - [1555] = 1390, - [1556] = 1556, - [1557] = 717, - [1558] = 1437, - [1559] = 658, - [1560] = 1560, + [1555] = 1555, + [1556] = 1433, + [1557] = 1397, + [1558] = 1558, + [1559] = 717, + [1560] = 1385, [1561] = 1561, - [1562] = 1562, - [1563] = 1563, - [1564] = 1560, - [1565] = 718, - [1566] = 728, - [1567] = 1391, - [1568] = 1568, - [1569] = 1453, - [1570] = 1570, - [1571] = 729, - [1572] = 1572, - [1573] = 1573, - [1574] = 1574, - [1575] = 1575, - [1576] = 1542, - [1577] = 1561, - [1578] = 730, - [1579] = 1476, + [1562] = 1477, + [1563] = 1404, + [1564] = 722, + [1565] = 1565, + [1566] = 1566, + [1567] = 1370, + [1568] = 1386, + [1569] = 1369, + [1570] = 1447, + [1571] = 1571, + [1572] = 1485, + [1573] = 728, + [1574] = 1566, + [1575] = 1487, + [1576] = 692, + [1577] = 1577, + [1578] = 1578, + [1579] = 729, [1580] = 1580, - [1581] = 1517, + [1581] = 1581, [1582] = 1582, - [1583] = 731, - [1584] = 732, - [1585] = 681, - [1586] = 1586, - [1587] = 1587, - [1588] = 682, + [1583] = 1583, + [1584] = 730, + [1585] = 1578, + [1586] = 1491, + [1587] = 1500, + [1588] = 731, [1589] = 1589, - [1590] = 1492, - [1591] = 1591, - [1592] = 1575, - [1593] = 735, - [1594] = 1594, - [1595] = 1431, - [1596] = 1596, - [1597] = 1432, + [1590] = 732, + [1591] = 681, + [1592] = 1460, + [1593] = 1469, + [1594] = 1426, + [1595] = 1546, + [1596] = 682, + [1597] = 1427, [1598] = 1598, - [1599] = 1462, - [1600] = 1467, - [1601] = 733, - [1602] = 1370, - [1603] = 736, - [1604] = 1572, - [1605] = 1501, - [1606] = 1606, - [1607] = 1607, - [1608] = 1608, - [1609] = 1609, - [1610] = 1610, - [1611] = 1611, - [1612] = 1506, - [1613] = 669, - [1614] = 1614, - [1615] = 1563, - [1616] = 1589, - [1617] = 1385, - [1618] = 1440, - [1619] = 1596, - [1620] = 1480, - [1621] = 1484, - [1622] = 1494, + [1599] = 735, + [1600] = 1600, + [1601] = 1601, + [1602] = 734, + [1603] = 1603, + [1604] = 1604, + [1605] = 1605, + [1606] = 1491, + [1607] = 736, + [1608] = 1561, + [1609] = 1601, + [1610] = 1382, + [1611] = 1441, + [1612] = 1612, + [1613] = 1479, + [1614] = 1483, + [1615] = 1494, + [1616] = 1616, + [1617] = 1617, + [1618] = 669, + [1619] = 1619, + [1620] = 1619, + [1621] = 1420, + [1622] = 1484, [1623] = 1623, - [1624] = 737, - [1625] = 1492, - [1626] = 1614, - [1627] = 1392, - [1628] = 1398, - [1629] = 1469, - [1630] = 1496, - [1631] = 738, + [1624] = 1553, + [1625] = 1565, + [1626] = 1431, + [1627] = 1387, + [1628] = 1492, + [1629] = 1501, + [1630] = 737, + [1631] = 1631, [1632] = 1632, - [1633] = 1424, - [1634] = 1634, - [1635] = 1487, + [1633] = 1633, + [1634] = 738, + [1635] = 1549, [1636] = 1636, - [1637] = 739, - [1638] = 683, + [1637] = 1553, + [1638] = 1638, [1639] = 1639, - [1640] = 1640, - [1641] = 741, - [1642] = 1556, + [1640] = 739, + [1641] = 683, + [1642] = 1642, [1643] = 1643, - [1644] = 1560, - [1645] = 1645, - [1646] = 742, - [1647] = 1647, + [1644] = 741, + [1645] = 1565, + [1646] = 1646, + [1647] = 1370, [1648] = 1648, - [1649] = 1649, - [1650] = 1650, - [1651] = 757, - [1652] = 1572, - [1653] = 1607, - [1654] = 1574, - [1655] = 1556, - [1656] = 1476, + [1649] = 1485, + [1650] = 742, + [1651] = 1496, + [1652] = 1652, + [1653] = 1600, + [1654] = 1481, + [1655] = 1496, + [1656] = 1656, [1657] = 1657, - [1658] = 743, - [1659] = 1465, - [1660] = 1660, - [1661] = 1661, + [1658] = 1460, + [1659] = 1659, + [1660] = 1546, + [1661] = 743, [1662] = 1662, - [1663] = 744, - [1664] = 1501, - [1665] = 1462, - [1666] = 1666, - [1667] = 1370, - [1668] = 1376, - [1669] = 1669, - [1670] = 284, - [1671] = 1589, - [1672] = 1385, - [1673] = 1440, - [1674] = 745, + [1663] = 1663, + [1664] = 1601, + [1665] = 1382, + [1666] = 1441, + [1667] = 1667, + [1668] = 1589, + [1669] = 1458, + [1670] = 1670, + [1671] = 744, + [1672] = 1672, + [1673] = 1408, + [1674] = 1538, [1675] = 1675, - [1676] = 1447, - [1677] = 1573, - [1678] = 1610, - [1679] = 1679, - [1680] = 1381, - [1681] = 1481, + [1676] = 1454, + [1677] = 1501, + [1678] = 1452, + [1679] = 1517, + [1680] = 1659, + [1681] = 1670, [1682] = 1682, - [1683] = 1679, - [1684] = 1684, - [1685] = 1437, - [1686] = 1466, - [1687] = 1647, - [1688] = 1587, - [1689] = 1506, - [1690] = 1485, - [1691] = 1418, - [1692] = 1692, - [1693] = 1553, - [1694] = 1694, - [1695] = 1695, - [1696] = 1582, - [1697] = 1380, - [1698] = 1698, - [1699] = 1546, - [1700] = 1554, - [1701] = 1442, - [1702] = 1591, - [1703] = 689, - [1704] = 1464, - [1705] = 1598, + [1683] = 1598, + [1684] = 1506, + [1685] = 1685, + [1686] = 1643, + [1687] = 1487, + [1688] = 1603, + [1689] = 1657, + [1690] = 1390, + [1691] = 1691, + [1692] = 1555, + [1693] = 1558, + [1694] = 1398, + [1695] = 1652, + [1696] = 284, + [1697] = 1462, + [1698] = 1612, + [1699] = 1371, + [1700] = 1700, + [1701] = 1457, + [1702] = 1490, + [1703] = 1583, + [1704] = 1417, + [1705] = 745, [1706] = 1706, - [1707] = 1707, - [1708] = 1463, - [1709] = 1491, - [1710] = 1543, - [1711] = 1395, - [1712] = 1712, - [1713] = 747, - [1714] = 1381, - [1715] = 1481, - [1716] = 673, - [1717] = 1485, - [1718] = 1574, - [1719] = 1582, - [1720] = 1380, - [1721] = 1721, - [1722] = 1464, - [1723] = 1598, - [1724] = 1404, - [1725] = 1725, - [1726] = 1657, + [1707] = 1408, + [1708] = 1538, + [1709] = 727, + [1710] = 1598, + [1711] = 1549, + [1712] = 1657, + [1713] = 1390, + [1714] = 1714, + [1715] = 1462, + [1716] = 1612, + [1717] = 1449, + [1718] = 1656, + [1719] = 1719, + [1720] = 1720, + [1721] = 1719, + [1722] = 746, + [1723] = 1582, + [1724] = 1467, + [1725] = 1581, + [1726] = 1726, [1727] = 1727, - [1728] = 1435, - [1729] = 1396, - [1730] = 1504, - [1731] = 1682, - [1732] = 1459, - [1733] = 750, - [1734] = 752, - [1735] = 1608, - [1736] = 1451, - [1737] = 1737, - [1738] = 748, - [1739] = 1739, - [1740] = 1478, - [1741] = 1741, - [1742] = 258, - [1743] = 1743, - [1744] = 1737, + [1728] = 1663, + [1729] = 1364, + [1730] = 1580, + [1731] = 689, + [1732] = 1430, + [1733] = 1476, + [1734] = 1391, + [1735] = 750, + [1736] = 755, + [1737] = 757, + [1738] = 1738, + [1739] = 1663, + [1740] = 1700, + [1741] = 1465, + [1742] = 1742, + [1743] = 748, + [1744] = 1744, [1745] = 1745, - [1746] = 1608, - [1747] = 1451, - [1748] = 1452, - [1749] = 872, - [1750] = 755, - [1751] = 1751, - [1752] = 1707, - [1753] = 1753, - [1754] = 1452, - [1755] = 1372, - [1756] = 1399, - [1757] = 1757, - [1758] = 1725, - [1759] = 1594, - [1760] = 1379, + [1746] = 258, + [1747] = 1465, + [1748] = 1379, + [1749] = 1415, + [1750] = 1750, + [1751] = 869, + [1752] = 756, + [1753] = 1750, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -4409,672 +4412,720 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(44); + if (eof) ADVANCE(46); ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 86, - ')', 63, - '*', 50, - '+', 79, - ',', 51, - '-', 81, - '.', 46, - '/', 82, - ':', 53, - ';', 52, - '<', 88, - '=', 56, - '>', 61, - '?', 72, - '[', 87, - ']', 70, - '{', 48, - '|', 66, - '}', 49, + '(', 88, + ')', 65, + '*', 52, + '+', 81, + ',', 53, + '-', 83, + '.', 48, + '/', 84, + ':', 55, + ';', 54, + '<', 91, + '=', 58, + '>', 63, + '?', 74, + '[', 89, + ']', 72, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(40); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + lookahead == ' ') SKIP(42); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 1: if (lookahead == '\n') ADVANCE(20); - if (lookahead == '"') ADVANCE(14); - if (lookahead == '$') ADVANCE(15); + if (lookahead == '"') ADVANCE(15); + if (lookahead == '$') ADVANCE(16); if (lookahead == '\\') ADVANCE(2); - if (lookahead != 0) ADVANCE(12); + if (lookahead != 0) ADVANCE(13); END_STATE(); case 2: - if (lookahead == '\n') ADVANCE(14); - if (lookahead == '"') ADVANCE(96); + if (lookahead == '\n') ADVANCE(15); + if (lookahead == '"') ADVANCE(99); if (lookahead == '\\') ADVANCE(1); - if (lookahead != 0) ADVANCE(12); + if (lookahead != 0) ADVANCE(13); END_STATE(); case 3: - if (lookahead == '\n') ADVANCE(14); - if (lookahead == '"') ADVANCE(95); + if (lookahead == '\n') ADVANCE(15); + if (lookahead == '"') ADVANCE(98); if (lookahead == '\\') ADVANCE(5); - if (lookahead != 0) ADVANCE(13); + if (lookahead != 0) ADVANCE(14); END_STATE(); case 4: - if (lookahead == '\n') ADVANCE(33); - if (lookahead == '}') ADVANCE(13); + if (lookahead == '\n') ADVANCE(35); + if (lookahead == '}') ADVANCE(14); if (lookahead != 0) ADVANCE(17); END_STATE(); case 5: if (lookahead == '\n') ADVANCE(18); - if (lookahead == '"') ADVANCE(99); + if (lookahead == '"') ADVANCE(102); if (lookahead == '$') ADVANCE(19); if (lookahead == '\\') ADVANCE(3); - if (lookahead != 0) ADVANCE(13); + if (lookahead != 0) ADVANCE(14); END_STATE(); case 6: ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 62, - '*', 50, - '+', 79, - '-', 80, - '.', 45, - '/', 82, - ':', 27, - '<', 88, - '=', 28, - '>', 61, - '?', 72, - '[', 87, - '{', 48, - '|', 66, - '}', 49, + '(', 64, + '*', 52, + '+', 81, + '-', 82, + '.', 47, + '/', 84, + ':', 29, + '<', 61, + '=', 30, + '>', 63, + '?', 74, + '[', 89, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(7); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 7: ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 62, - '*', 50, - '+', 79, - '-', 80, - '.', 45, - '/', 82, - ':', 27, - '<', 59, - '=', 28, - '>', 61, - '?', 72, - '[', 69, - '{', 48, - '|', 66, - '}', 49, + '(', 64, + '*', 52, + '+', 81, + '-', 82, + '.', 47, + '/', 84, + ':', 29, + '<', 61, + '=', 30, + '>', 63, + '?', 74, + '[', 71, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(7); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 8: ADVANCE_MAP( - '!', 67, - '"', 12, - '(', 62, - ')', 63, - '+', 79, - ',', 51, - '-', 80, - '.', 24, - '/', 26, - ':', 53, - '<', 58, - '=', 57, - '>', 60, - '[', 69, - ']', 70, - '{', 48, - '|', 65, - '}', 49, + '!', 69, + '"', 13, + '(', 64, + ')', 65, + '+', 81, + ',', 53, + '-', 82, + '.', 26, + '/', 28, + ':', 55, + '<', 60, + '=', 59, + '>', 62, + '[', 71, + ']', 72, + '{', 50, + '|', 67, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(8); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 9: - if (lookahead == '!') ADVANCE(67); - if (lookahead == '(') ADVANCE(86); - if (lookahead == '-') ADVANCE(29); - if (lookahead == '/') ADVANCE(26); - if (lookahead == '<') ADVANCE(58); - if (lookahead == '=') ADVANCE(54); - if (lookahead == '{') ADVANCE(48); + ADVANCE_MAP( + '!', 69, + '"', 15, + '(', 64, + ')', 65, + '+', 81, + ',', 53, + '-', 31, + '.', 47, + '/', 28, + ':', 55, + '<', 60, + '=', 59, + '>', 62, + '[', 71, + ']', 72, + '{', 50, + '|', 67, + '}', 51, + ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(11); + lookahead == ' ') SKIP(9); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 10: - if (lookahead == '!') ADVANCE(67); - if (lookahead == '-') ADVANCE(29); - if (lookahead == '/') ADVANCE(25); - if (lookahead == '}') ADVANCE(49); + if (lookahead == '!') ADVANCE(69); + if (lookahead == '(') ADVANCE(88); + if (lookahead == '-') ADVANCE(31); + if (lookahead == '/') ADVANCE(28); + if (lookahead == '=') ADVANCE(56); + if (lookahead == '{') ADVANCE(50); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(10); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + lookahead == ' ') SKIP(12); END_STATE(); case 11: - if (lookahead == '!') ADVANCE(67); - if (lookahead == '-') ADVANCE(29); - if (lookahead == '/') ADVANCE(26); - if (lookahead == '<') ADVANCE(58); - if (lookahead == '=') ADVANCE(54); - if (lookahead == '{') ADVANCE(48); + if (lookahead == '!') ADVANCE(69); + if (lookahead == '-') ADVANCE(31); + if (lookahead == '/') ADVANCE(27); + if (lookahead == '}') ADVANCE(51); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(11); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 12: - if (lookahead == '"') ADVANCE(94); - if (lookahead == '$') ADVANCE(15); - if (lookahead == '\\') ADVANCE(35); - if (lookahead != 0) ADVANCE(12); + if (lookahead == '!') ADVANCE(69); + if (lookahead == '-') ADVANCE(31); + if (lookahead == '/') ADVANCE(28); + if (lookahead == '=') ADVANCE(56); + if (lookahead == '{') ADVANCE(50); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(12); END_STATE(); case 13: - if (lookahead == '"') ADVANCE(94); - if (lookahead == '$') ADVANCE(19); - if (lookahead == '\\') ADVANCE(39); + if (lookahead == '"') ADVANCE(97); + if (lookahead == '$') ADVANCE(16); + if (lookahead == '\\') ADVANCE(37); if (lookahead != 0) ADVANCE(13); END_STATE(); case 14: - if (lookahead == '"') ADVANCE(94); - if (lookahead == '\\') ADVANCE(37); + if (lookahead == '"') ADVANCE(97); + if (lookahead == '$') ADVANCE(19); + if (lookahead == '\\') ADVANCE(41); if (lookahead != 0) ADVANCE(14); END_STATE(); case 15: - if (lookahead == '"') ADVANCE(96); - if (lookahead == '\\') ADVANCE(1); - if (lookahead == '{') ADVANCE(17); - if (lookahead != 0) ADVANCE(12); + if (lookahead == '"') ADVANCE(97); + if (lookahead == '\\') ADVANCE(39); + if (lookahead != 0) ADVANCE(15); END_STATE(); case 16: - ADVANCE_MAP( - '"', 14, - '(', 62, - ')', 63, - ',', 51, - '-', 29, - '.', 23, - '/', 26, - ':', 53, - '=', 30, - ']', 70, - '{', 48, - '}', 49, - ); - if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(16); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + if (lookahead == '"') ADVANCE(99); + if (lookahead == '\\') ADVANCE(1); + if (lookahead == '{') ADVANCE(17); + if (lookahead != 0) ADVANCE(13); END_STATE(); case 17: - if (lookahead == '"') ADVANCE(97); + if (lookahead == '"') ADVANCE(100); if (lookahead == '\\') ADVANCE(4); - if (lookahead == '}') ADVANCE(13); + if (lookahead == '}') ADVANCE(14); if (lookahead != 0) ADVANCE(17); END_STATE(); case 18: - if (lookahead == '"') ADVANCE(98); - if (lookahead == '$') ADVANCE(32); - if (lookahead == '\\') ADVANCE(38); + if (lookahead == '"') ADVANCE(101); + if (lookahead == '$') ADVANCE(34); + if (lookahead == '\\') ADVANCE(40); if (lookahead != 0) ADVANCE(18); END_STATE(); case 19: - if (lookahead == '"') ADVANCE(95); + if (lookahead == '"') ADVANCE(98); if (lookahead == '\\') ADVANCE(5); if (lookahead == '{') ADVANCE(17); - if (lookahead != 0) ADVANCE(13); + if (lookahead != 0) ADVANCE(14); END_STATE(); case 20: - if (lookahead == '$') ADVANCE(31); - if (lookahead == '\\') ADVANCE(36); + if (lookahead == '$') ADVANCE(33); + if (lookahead == '\\') ADVANCE(38); if (lookahead != 0 && lookahead != '"') ADVANCE(20); END_STATE(); case 21: - if (lookahead == '&') ADVANCE(74); + if (lookahead == '&') ADVANCE(76); END_STATE(); case 22: - if (lookahead == '.') ADVANCE(91); + ADVANCE_MAP( + '(', 64, + ')', 65, + ',', 53, + '-', 31, + '.', 25, + '/', 28, + ':', 55, + '<', 90, + '=', 32, + ']', 72, + '{', 50, + '}', 51, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(23); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 23: - if (lookahead == '.') ADVANCE(89); + ADVANCE_MAP( + '(', 64, + ')', 65, + ',', 53, + '-', 31, + '.', 25, + '/', 28, + ':', 55, + '=', 32, + ']', 72, + '{', 50, + '}', 51, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(23); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); case 24: - if (lookahead == '.') ADVANCE(22); + if (lookahead == '.') ADVANCE(94); END_STATE(); case 25: - if (lookahead == '/') ADVANCE(102); + if (lookahead == '.') ADVANCE(92); END_STATE(); case 26: - if (lookahead == '/') ADVANCE(103); + if (lookahead == '.') ADVANCE(24); END_STATE(); case 27: - if (lookahead == ':') ADVANCE(47); + if (lookahead == '/') ADVANCE(105); END_STATE(); case 28: - if (lookahead == '=') ADVANCE(75); + if (lookahead == '/') ADVANCE(106); END_STATE(); case 29: - if (lookahead == '>') ADVANCE(64); + if (lookahead == ':') ADVANCE(49); END_STATE(); case 30: - if (lookahead == '>') ADVANCE(71); + if (lookahead == '=') ADVANCE(77); END_STATE(); case 31: - if (lookahead == '{') ADVANCE(33); - if (lookahead != 0) ADVANCE(20); + if (lookahead == '>') ADVANCE(66); END_STATE(); case 32: - if (lookahead == '{') ADVANCE(33); - if (lookahead != 0) ADVANCE(18); + if (lookahead == '>') ADVANCE(73); END_STATE(); case 33: - if (lookahead == '}') ADVANCE(18); - if (lookahead != 0) ADVANCE(33); + if (lookahead == '{') ADVANCE(35); + if (lookahead != 0) ADVANCE(20); END_STATE(); case 34: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + if (lookahead == '{') ADVANCE(35); + if (lookahead != 0) ADVANCE(18); END_STATE(); case 35: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(12); + if (lookahead == '}') ADVANCE(18); + if (lookahead != 0) ADVANCE(35); END_STATE(); case 36: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(20); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(95); END_STATE(); case 37: if (lookahead != 0 && - lookahead != '\n') ADVANCE(14); + lookahead != '\n') ADVANCE(13); END_STATE(); case 38: if (lookahead != 0 && - lookahead != '\n') ADVANCE(18); + lookahead != '\n') ADVANCE(20); END_STATE(); case 39: if (lookahead != 0 && - lookahead != '\n') ADVANCE(13); + lookahead != '\n') ADVANCE(15); END_STATE(); case 40: - if (eof) ADVANCE(44); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(18); + END_STATE(); + case 41: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(14); + END_STATE(); + case 42: + if (eof) ADVANCE(46); ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 62, - ')', 63, - '*', 50, - '+', 79, - ',', 51, - '-', 81, - '.', 46, - '/', 82, - ':', 53, - ';', 52, - '<', 59, - '=', 56, - '>', 61, - '?', 72, - '[', 69, - ']', 70, - '{', 48, - '|', 66, - '}', 49, + '(', 64, + ')', 65, + '*', 52, + '+', 81, + ',', 53, + '-', 83, + '.', 48, + '/', 84, + ':', 55, + ';', 54, + '<', 61, + '=', 58, + '>', 63, + '?', 74, + '[', 71, + ']', 72, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(40); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + lookahead == ' ') SKIP(42); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); - case 41: - if (eof) ADVANCE(44); + case 43: + if (eof) ADVANCE(46); ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 62, - ')', 63, - '*', 50, - '+', 79, - ',', 51, - '-', 80, - '.', 45, - '/', 83, - ':', 53, - ';', 52, - '<', 88, - '=', 55, - '>', 61, - '?', 72, - '[', 87, - ']', 70, - '{', 48, - '|', 66, - '}', 49, + '(', 64, + ')', 65, + '*', 52, + '+', 81, + ',', 53, + '-', 82, + '.', 47, + '/', 85, + ':', 55, + ';', 54, + '<', 61, + '=', 57, + '>', 63, + '?', 74, + '[', 89, + ']', 72, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(42); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + lookahead == ' ') SKIP(44); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); - case 42: - if (eof) ADVANCE(44); + case 44: + if (eof) ADVANCE(46); ADVANCE_MAP( - '!', 68, - '"', 12, - '%', 84, + '!', 70, + '"', 13, + '%', 86, '&', 21, - '(', 62, - ')', 63, - '*', 50, - '+', 79, - ',', 51, - '-', 80, - '.', 45, - '/', 83, - ':', 53, - ';', 52, - '<', 59, - '=', 55, - '>', 61, - '?', 72, - '[', 69, - ']', 70, - '{', 48, - '|', 66, - '}', 49, + '(', 64, + ')', 65, + '*', 52, + '+', 81, + ',', 53, + '-', 82, + '.', 47, + '/', 85, + ':', 55, + ';', 54, + '<', 61, + '=', 57, + '>', 63, + '?', 74, + '[', 71, + ']', 72, + '{', 50, + '|', 68, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(42); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + lookahead == ' ') SKIP(44); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); - case 43: - if (eof) ADVANCE(44); + case 45: + if (eof) ADVANCE(46); ADVANCE_MAP( - '!', 67, - '"', 12, - '(', 62, - '+', 79, - '-', 80, - '/', 25, - ':', 27, - '<', 58, - '=', 54, - '[', 69, - '{', 48, - '|', 65, - '}', 49, + '!', 69, + '"', 13, + '(', 64, + '+', 81, + '-', 82, + '/', 27, + ':', 29, + '<', 60, + '=', 56, + '[', 71, + '{', 50, + '|', 67, + '}', 51, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(43); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + lookahead == ' ') SKIP(45); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); - case 44: + case 46: ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); - case 45: + case 47: ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); - case 46: + case 48: ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(90); + if (lookahead == '.') ADVANCE(93); END_STATE(); - case 47: + case 49: ACCEPT_TOKEN(anon_sym_COLON_COLON); END_STATE(); - case 48: + case 50: ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); - case 49: + case 51: ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); - case 50: + case 52: ACCEPT_TOKEN(anon_sym_STAR); END_STATE(); - case 51: + case 53: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 52: + case 54: ACCEPT_TOKEN(anon_sym_SEMI); END_STATE(); - case 53: + case 55: ACCEPT_TOKEN(anon_sym_COLON); - if (lookahead == ':') ADVANCE(47); + if (lookahead == ':') ADVANCE(49); END_STATE(); - case 54: + case 56: ACCEPT_TOKEN(anon_sym_EQ); END_STATE(); - case 55: + case 57: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(75); + if (lookahead == '=') ADVANCE(77); END_STATE(); - case 56: + case 58: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(75); - if (lookahead == '>') ADVANCE(71); + if (lookahead == '=') ADVANCE(77); + if (lookahead == '>') ADVANCE(73); END_STATE(); - case 57: + case 59: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '>') ADVANCE(71); + if (lookahead == '>') ADVANCE(73); END_STATE(); - case 58: + case 60: ACCEPT_TOKEN(anon_sym_LT); END_STATE(); - case 59: + case 61: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '=') ADVANCE(77); + if (lookahead == '=') ADVANCE(79); END_STATE(); - case 60: + case 62: ACCEPT_TOKEN(anon_sym_GT); END_STATE(); - case 61: + case 63: ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(78); + if (lookahead == '=') ADVANCE(80); END_STATE(); - case 62: + case 64: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 63: + case 65: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); - case 64: + case 66: ACCEPT_TOKEN(anon_sym_DASH_GT); END_STATE(); - case 65: + case 67: ACCEPT_TOKEN(anon_sym_PIPE); END_STATE(); - case 66: + case 68: ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '>') ADVANCE(85); - if (lookahead == '|') ADVANCE(73); + if (lookahead == '>') ADVANCE(87); + if (lookahead == '|') ADVANCE(75); END_STATE(); - case 67: + case 69: ACCEPT_TOKEN(anon_sym_BANG); END_STATE(); - case 68: + case 70: ACCEPT_TOKEN(anon_sym_BANG); - if (lookahead == '=') ADVANCE(76); + if (lookahead == '=') ADVANCE(78); END_STATE(); - case 69: + case 71: ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); - case 70: + case 72: ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); - case 71: + case 73: ACCEPT_TOKEN(anon_sym_EQ_GT); END_STATE(); - case 72: + case 74: ACCEPT_TOKEN(anon_sym_QMARK); END_STATE(); - case 73: + case 75: ACCEPT_TOKEN(anon_sym_PIPE_PIPE); END_STATE(); - case 74: + case 76: ACCEPT_TOKEN(anon_sym_AMP_AMP); END_STATE(); - case 75: + case 77: ACCEPT_TOKEN(anon_sym_EQ_EQ); END_STATE(); - case 76: + case 78: ACCEPT_TOKEN(anon_sym_BANG_EQ); END_STATE(); - case 77: + case 79: ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); - case 78: + case 80: ACCEPT_TOKEN(anon_sym_GT_EQ); END_STATE(); - case 79: + case 81: ACCEPT_TOKEN(anon_sym_PLUS); END_STATE(); - case 80: + case 82: ACCEPT_TOKEN(anon_sym_DASH); END_STATE(); - case 81: + case 83: ACCEPT_TOKEN(anon_sym_DASH); - if (lookahead == '>') ADVANCE(64); + if (lookahead == '>') ADVANCE(66); END_STATE(); - case 82: + case 84: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(102); + if (lookahead == '/') ADVANCE(105); END_STATE(); - case 83: + case 85: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(103); + if (lookahead == '/') ADVANCE(106); END_STATE(); - case 84: + case 86: ACCEPT_TOKEN(anon_sym_PERCENT); END_STATE(); - case 85: + case 87: ACCEPT_TOKEN(anon_sym_PIPE_GT); END_STATE(); - case 86: + case 88: ACCEPT_TOKEN(anon_sym_LPAREN2); END_STATE(); - case 87: + case 89: ACCEPT_TOKEN(anon_sym_LBRACK2); END_STATE(); - case 88: + case 90: ACCEPT_TOKEN(anon_sym_LT2); - if (lookahead == '=') ADVANCE(77); END_STATE(); - case 89: + case 91: + ACCEPT_TOKEN(anon_sym_LT2); + if (lookahead == '=') ADVANCE(79); + END_STATE(); + case 92: ACCEPT_TOKEN(anon_sym_DOT_DOT); END_STATE(); - case 90: + case 93: ACCEPT_TOKEN(anon_sym_DOT_DOT); - if (lookahead == '.') ADVANCE(91); + if (lookahead == '.') ADVANCE(94); END_STATE(); - case 91: + case 94: ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); END_STATE(); - case 92: + case 95: ACCEPT_TOKEN(sym_float); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(95); END_STATE(); - case 93: + case 96: ACCEPT_TOKEN(sym_integer); - if (lookahead == '.') ADVANCE(34); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93); + if (lookahead == '.') ADVANCE(36); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(96); END_STATE(); - case 94: + case 97: ACCEPT_TOKEN(sym_string); END_STATE(); - case 95: + case 98: ACCEPT_TOKEN(sym_string); - if (lookahead == '"') ADVANCE(98); - if (lookahead == '$') ADVANCE(32); - if (lookahead == '\\') ADVANCE(38); + if (lookahead == '"') ADVANCE(101); + if (lookahead == '$') ADVANCE(34); + if (lookahead == '\\') ADVANCE(40); if (lookahead != 0) ADVANCE(18); END_STATE(); - case 96: + case 99: ACCEPT_TOKEN(sym_string); - if (lookahead == '$') ADVANCE(31); - if (lookahead == '\\') ADVANCE(36); + if (lookahead == '$') ADVANCE(33); + if (lookahead == '\\') ADVANCE(38); if (lookahead != 0 && lookahead != '"') ADVANCE(20); END_STATE(); - case 97: + case 100: ACCEPT_TOKEN(sym_string); if (lookahead == '}') ADVANCE(18); - if (lookahead != 0) ADVANCE(33); + if (lookahead != 0) ADVANCE(35); END_STATE(); - case 98: + case 101: ACCEPT_TOKEN(sym_interpolated_string); END_STATE(); - case 99: + case 102: ACCEPT_TOKEN(sym_interpolated_string); - if (lookahead == '"') ADVANCE(94); - if (lookahead == '\\') ADVANCE(37); - if (lookahead != 0) ADVANCE(14); + if (lookahead == '"') ADVANCE(97); + if (lookahead == '\\') ADVANCE(39); + if (lookahead != 0) ADVANCE(15); END_STATE(); - case 100: + case 103: ACCEPT_TOKEN(sym_identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(100); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(103); END_STATE(); - case 101: + case 104: ACCEPT_TOKEN(sym__doc_comment_line); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(101); + lookahead != '\r') ADVANCE(104); END_STATE(); - case 102: + case 105: ACCEPT_TOKEN(sym_line_comment); - if (lookahead == '/') ADVANCE(101); + if (lookahead == '/') ADVANCE(104); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(103); + lookahead != '\r') ADVANCE(106); END_STATE(); - case 103: + case 106: ACCEPT_TOKEN(sym_line_comment); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(103); + lookahead != '\r') ADVANCE(106); END_STATE(); default: return false; @@ -5624,25 +5675,25 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { static const TSLexMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0, .external_lex_state = 1}, - [1] = {.lex_state = 43}, - [2] = {.lex_state = 43}, - [3] = {.lex_state = 43}, - [4] = {.lex_state = 43}, + [1] = {.lex_state = 45}, + [2] = {.lex_state = 45}, + [3] = {.lex_state = 45}, + [4] = {.lex_state = 45}, [5] = {.lex_state = 6, .external_lex_state = 2}, - [6] = {.lex_state = 43}, - [7] = {.lex_state = 43}, - [8] = {.lex_state = 43}, - [9] = {.lex_state = 43}, - [10] = {.lex_state = 43}, - [11] = {.lex_state = 43}, - [12] = {.lex_state = 43}, - [13] = {.lex_state = 43}, - [14] = {.lex_state = 43}, - [15] = {.lex_state = 43}, - [16] = {.lex_state = 43}, - [17] = {.lex_state = 43}, - [18] = {.lex_state = 41, .external_lex_state = 2}, - [19] = {.lex_state = 41, .external_lex_state = 1}, + [6] = {.lex_state = 45}, + [7] = {.lex_state = 45}, + [8] = {.lex_state = 45}, + [9] = {.lex_state = 45}, + [10] = {.lex_state = 45}, + [11] = {.lex_state = 45}, + [12] = {.lex_state = 45}, + [13] = {.lex_state = 45}, + [14] = {.lex_state = 45}, + [15] = {.lex_state = 45}, + [16] = {.lex_state = 45}, + [17] = {.lex_state = 45}, + [18] = {.lex_state = 43, .external_lex_state = 2}, + [19] = {.lex_state = 43, .external_lex_state = 1}, [20] = {.lex_state = 8}, [21] = {.lex_state = 8}, [22] = {.lex_state = 8}, @@ -5849,74 +5900,74 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [223] = {.lex_state = 8}, [224] = {.lex_state = 8}, [225] = {.lex_state = 8}, - [226] = {.lex_state = 43}, - [227] = {.lex_state = 43}, - [228] = {.lex_state = 41, .external_lex_state = 2}, - [229] = {.lex_state = 43}, - [230] = {.lex_state = 43}, - [231] = {.lex_state = 41, .external_lex_state = 2}, - [232] = {.lex_state = 41, .external_lex_state = 2}, - [233] = {.lex_state = 41, .external_lex_state = 2}, - [234] = {.lex_state = 41, .external_lex_state = 2}, - [235] = {.lex_state = 41, .external_lex_state = 2}, - [236] = {.lex_state = 41, .external_lex_state = 2}, - [237] = {.lex_state = 41, .external_lex_state = 2}, - [238] = {.lex_state = 41, .external_lex_state = 2}, - [239] = {.lex_state = 41, .external_lex_state = 2}, - [240] = {.lex_state = 41, .external_lex_state = 2}, - [241] = {.lex_state = 41, .external_lex_state = 2}, - [242] = {.lex_state = 41, .external_lex_state = 2}, - [243] = {.lex_state = 41, .external_lex_state = 2}, - [244] = {.lex_state = 41, .external_lex_state = 2}, - [245] = {.lex_state = 41, .external_lex_state = 2}, - [246] = {.lex_state = 41, .external_lex_state = 2}, - [247] = {.lex_state = 41, .external_lex_state = 2}, - [248] = {.lex_state = 41, .external_lex_state = 2}, - [249] = {.lex_state = 41, .external_lex_state = 2}, - [250] = {.lex_state = 41, .external_lex_state = 2}, - [251] = {.lex_state = 41, .external_lex_state = 2}, - [252] = {.lex_state = 41, .external_lex_state = 2}, - [253] = {.lex_state = 41, .external_lex_state = 2}, - [254] = {.lex_state = 41, .external_lex_state = 2}, - [255] = {.lex_state = 41, .external_lex_state = 2}, - [256] = {.lex_state = 41, .external_lex_state = 2}, - [257] = {.lex_state = 41, .external_lex_state = 2}, - [258] = {.lex_state = 41, .external_lex_state = 2}, - [259] = {.lex_state = 41, .external_lex_state = 2}, - [260] = {.lex_state = 41, .external_lex_state = 2}, - [261] = {.lex_state = 41, .external_lex_state = 2}, - [262] = {.lex_state = 41, .external_lex_state = 2}, - [263] = {.lex_state = 41, .external_lex_state = 2}, - [264] = {.lex_state = 41, .external_lex_state = 2}, - [265] = {.lex_state = 41, .external_lex_state = 2}, - [266] = {.lex_state = 41, .external_lex_state = 2}, - [267] = {.lex_state = 41, .external_lex_state = 2}, - [268] = {.lex_state = 41, .external_lex_state = 2}, - [269] = {.lex_state = 41, .external_lex_state = 2}, - [270] = {.lex_state = 41, .external_lex_state = 2}, - [271] = {.lex_state = 41, .external_lex_state = 2}, - [272] = {.lex_state = 41, .external_lex_state = 2}, - [273] = {.lex_state = 41, .external_lex_state = 2}, - [274] = {.lex_state = 41, .external_lex_state = 2}, - [275] = {.lex_state = 41, .external_lex_state = 2}, - [276] = {.lex_state = 41, .external_lex_state = 2}, - [277] = {.lex_state = 41, .external_lex_state = 2}, - [278] = {.lex_state = 41, .external_lex_state = 2}, - [279] = {.lex_state = 41, .external_lex_state = 2}, - [280] = {.lex_state = 41, .external_lex_state = 2}, - [281] = {.lex_state = 41, .external_lex_state = 2}, - [282] = {.lex_state = 41, .external_lex_state = 2}, - [283] = {.lex_state = 41, .external_lex_state = 2}, - [284] = {.lex_state = 41, .external_lex_state = 2}, - [285] = {.lex_state = 41, .external_lex_state = 2}, - [286] = {.lex_state = 41, .external_lex_state = 2}, - [287] = {.lex_state = 41, .external_lex_state = 2}, - [288] = {.lex_state = 41, .external_lex_state = 2}, - [289] = {.lex_state = 41, .external_lex_state = 2}, - [290] = {.lex_state = 41, .external_lex_state = 2}, - [291] = {.lex_state = 41, .external_lex_state = 2}, - [292] = {.lex_state = 41, .external_lex_state = 2}, - [293] = {.lex_state = 41, .external_lex_state = 2}, + [226] = {.lex_state = 45}, + [227] = {.lex_state = 45}, + [228] = {.lex_state = 43, .external_lex_state = 2}, + [229] = {.lex_state = 45}, + [230] = {.lex_state = 45}, + [231] = {.lex_state = 43, .external_lex_state = 2}, + [232] = {.lex_state = 43, .external_lex_state = 2}, + [233] = {.lex_state = 43, .external_lex_state = 2}, + [234] = {.lex_state = 43, .external_lex_state = 2}, + [235] = {.lex_state = 43, .external_lex_state = 2}, + [236] = {.lex_state = 43, .external_lex_state = 2}, + [237] = {.lex_state = 43, .external_lex_state = 2}, + [238] = {.lex_state = 43, .external_lex_state = 2}, + [239] = {.lex_state = 43, .external_lex_state = 2}, + [240] = {.lex_state = 43, .external_lex_state = 2}, + [241] = {.lex_state = 43, .external_lex_state = 2}, + [242] = {.lex_state = 43, .external_lex_state = 2}, + [243] = {.lex_state = 43, .external_lex_state = 2}, + [244] = {.lex_state = 43, .external_lex_state = 2}, + [245] = {.lex_state = 43, .external_lex_state = 2}, + [246] = {.lex_state = 43, .external_lex_state = 2}, + [247] = {.lex_state = 43, .external_lex_state = 2}, + [248] = {.lex_state = 43, .external_lex_state = 2}, + [249] = {.lex_state = 43, .external_lex_state = 2}, + [250] = {.lex_state = 43, .external_lex_state = 2}, + [251] = {.lex_state = 43, .external_lex_state = 2}, + [252] = {.lex_state = 43, .external_lex_state = 2}, + [253] = {.lex_state = 43, .external_lex_state = 2}, + [254] = {.lex_state = 43, .external_lex_state = 2}, + [255] = {.lex_state = 43, .external_lex_state = 2}, + [256] = {.lex_state = 43, .external_lex_state = 2}, + [257] = {.lex_state = 43, .external_lex_state = 2}, + [258] = {.lex_state = 43, .external_lex_state = 2}, + [259] = {.lex_state = 43, .external_lex_state = 2}, + [260] = {.lex_state = 43, .external_lex_state = 2}, + [261] = {.lex_state = 43, .external_lex_state = 2}, + [262] = {.lex_state = 43, .external_lex_state = 2}, + [263] = {.lex_state = 43, .external_lex_state = 2}, + [264] = {.lex_state = 43, .external_lex_state = 2}, + [265] = {.lex_state = 43, .external_lex_state = 2}, + [266] = {.lex_state = 43, .external_lex_state = 2}, + [267] = {.lex_state = 43, .external_lex_state = 2}, + [268] = {.lex_state = 43, .external_lex_state = 2}, + [269] = {.lex_state = 43, .external_lex_state = 2}, + [270] = {.lex_state = 43, .external_lex_state = 2}, + [271] = {.lex_state = 43, .external_lex_state = 2}, + [272] = {.lex_state = 43, .external_lex_state = 2}, + [273] = {.lex_state = 43, .external_lex_state = 2}, + [274] = {.lex_state = 43, .external_lex_state = 2}, + [275] = {.lex_state = 43, .external_lex_state = 2}, + [276] = {.lex_state = 43, .external_lex_state = 2}, + [277] = {.lex_state = 43, .external_lex_state = 2}, + [278] = {.lex_state = 43, .external_lex_state = 2}, + [279] = {.lex_state = 43, .external_lex_state = 2}, + [280] = {.lex_state = 43, .external_lex_state = 2}, + [281] = {.lex_state = 43, .external_lex_state = 2}, + [282] = {.lex_state = 43, .external_lex_state = 2}, + [283] = {.lex_state = 43, .external_lex_state = 2}, + [284] = {.lex_state = 43, .external_lex_state = 2}, + [285] = {.lex_state = 43, .external_lex_state = 2}, + [286] = {.lex_state = 43, .external_lex_state = 2}, + [287] = {.lex_state = 43, .external_lex_state = 2}, + [288] = {.lex_state = 43, .external_lex_state = 2}, + [289] = {.lex_state = 43, .external_lex_state = 2}, + [290] = {.lex_state = 43, .external_lex_state = 2}, + [291] = {.lex_state = 43, .external_lex_state = 2}, + [292] = {.lex_state = 43, .external_lex_state = 2}, + [293] = {.lex_state = 43, .external_lex_state = 2}, [294] = {.lex_state = 6, .external_lex_state = 2}, [295] = {.lex_state = 6, .external_lex_state = 2}, [296] = {.lex_state = 6, .external_lex_state = 2}, @@ -6017,21 +6068,21 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [391] = {.lex_state = 6, .external_lex_state = 2}, [392] = {.lex_state = 6, .external_lex_state = 2}, [393] = {.lex_state = 6, .external_lex_state = 2}, - [394] = {.lex_state = 41, .external_lex_state = 2}, - [395] = {.lex_state = 41, .external_lex_state = 2}, - [396] = {.lex_state = 43}, - [397] = {.lex_state = 43}, - [398] = {.lex_state = 43}, - [399] = {.lex_state = 41, .external_lex_state = 1}, + [394] = {.lex_state = 43, .external_lex_state = 2}, + [395] = {.lex_state = 43, .external_lex_state = 2}, + [396] = {.lex_state = 45}, + [397] = {.lex_state = 45}, + [398] = {.lex_state = 45}, + [399] = {.lex_state = 43, .external_lex_state = 1}, [400] = {.lex_state = 0}, [401] = {.lex_state = 0}, [402] = {.lex_state = 0}, [403] = {.lex_state = 0}, [404] = {.lex_state = 0}, - [405] = {.lex_state = 41, .external_lex_state = 2}, - [406] = {.lex_state = 41, .external_lex_state = 1}, - [407] = {.lex_state = 41, .external_lex_state = 2}, - [408] = {.lex_state = 41, .external_lex_state = 1}, + [405] = {.lex_state = 43, .external_lex_state = 2}, + [406] = {.lex_state = 43, .external_lex_state = 1}, + [407] = {.lex_state = 43, .external_lex_state = 2}, + [408] = {.lex_state = 43, .external_lex_state = 1}, [409] = {.lex_state = 0}, [410] = {.lex_state = 0}, [411] = {.lex_state = 0}, @@ -6060,245 +6111,245 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [434] = {.lex_state = 0}, [435] = {.lex_state = 0}, [436] = {.lex_state = 0}, - [437] = {.lex_state = 43}, - [438] = {.lex_state = 41, .external_lex_state = 1}, - [439] = {.lex_state = 41, .external_lex_state = 1}, - [440] = {.lex_state = 41, .external_lex_state = 1}, - [441] = {.lex_state = 41, .external_lex_state = 2}, - [442] = {.lex_state = 41, .external_lex_state = 1}, - [443] = {.lex_state = 41, .external_lex_state = 1}, - [444] = {.lex_state = 41, .external_lex_state = 1}, - [445] = {.lex_state = 41, .external_lex_state = 1}, - [446] = {.lex_state = 41, .external_lex_state = 1}, - [447] = {.lex_state = 41, .external_lex_state = 1}, - [448] = {.lex_state = 41, .external_lex_state = 1}, - [449] = {.lex_state = 41, .external_lex_state = 1}, - [450] = {.lex_state = 41, .external_lex_state = 1}, - [451] = {.lex_state = 41, .external_lex_state = 1}, - [452] = {.lex_state = 41, .external_lex_state = 1}, - [453] = {.lex_state = 41, .external_lex_state = 2}, - [454] = {.lex_state = 41, .external_lex_state = 2}, - [455] = {.lex_state = 41, .external_lex_state = 1}, - [456] = {.lex_state = 41, .external_lex_state = 1}, - [457] = {.lex_state = 41, .external_lex_state = 2}, - [458] = {.lex_state = 41, .external_lex_state = 1}, - [459] = {.lex_state = 41, .external_lex_state = 1}, - [460] = {.lex_state = 41, .external_lex_state = 1}, - [461] = {.lex_state = 41, .external_lex_state = 1}, - [462] = {.lex_state = 41, .external_lex_state = 1}, - [463] = {.lex_state = 41, .external_lex_state = 2}, - [464] = {.lex_state = 41, .external_lex_state = 1}, - [465] = {.lex_state = 41, .external_lex_state = 1}, - [466] = {.lex_state = 41, .external_lex_state = 1}, - [467] = {.lex_state = 41, .external_lex_state = 1}, - [468] = {.lex_state = 41, .external_lex_state = 1}, - [469] = {.lex_state = 41, .external_lex_state = 2}, - [470] = {.lex_state = 41, .external_lex_state = 1}, - [471] = {.lex_state = 41, .external_lex_state = 1}, - [472] = {.lex_state = 41, .external_lex_state = 1}, - [473] = {.lex_state = 41, .external_lex_state = 2}, - [474] = {.lex_state = 41, .external_lex_state = 1}, - [475] = {.lex_state = 41, .external_lex_state = 1}, - [476] = {.lex_state = 41, .external_lex_state = 1}, - [477] = {.lex_state = 41, .external_lex_state = 2}, - [478] = {.lex_state = 41, .external_lex_state = 1}, - [479] = {.lex_state = 41, .external_lex_state = 1}, - [480] = {.lex_state = 41, .external_lex_state = 2}, - [481] = {.lex_state = 41, .external_lex_state = 1}, + [437] = {.lex_state = 45}, + [438] = {.lex_state = 43, .external_lex_state = 1}, + [439] = {.lex_state = 43, .external_lex_state = 1}, + [440] = {.lex_state = 43, .external_lex_state = 1}, + [441] = {.lex_state = 43, .external_lex_state = 2}, + [442] = {.lex_state = 43, .external_lex_state = 1}, + [443] = {.lex_state = 43, .external_lex_state = 1}, + [444] = {.lex_state = 43, .external_lex_state = 1}, + [445] = {.lex_state = 43, .external_lex_state = 1}, + [446] = {.lex_state = 43, .external_lex_state = 1}, + [447] = {.lex_state = 43, .external_lex_state = 1}, + [448] = {.lex_state = 43, .external_lex_state = 1}, + [449] = {.lex_state = 43, .external_lex_state = 1}, + [450] = {.lex_state = 43, .external_lex_state = 1}, + [451] = {.lex_state = 43, .external_lex_state = 1}, + [452] = {.lex_state = 43, .external_lex_state = 1}, + [453] = {.lex_state = 43, .external_lex_state = 2}, + [454] = {.lex_state = 43, .external_lex_state = 2}, + [455] = {.lex_state = 43, .external_lex_state = 1}, + [456] = {.lex_state = 43, .external_lex_state = 1}, + [457] = {.lex_state = 43, .external_lex_state = 2}, + [458] = {.lex_state = 43, .external_lex_state = 1}, + [459] = {.lex_state = 43, .external_lex_state = 1}, + [460] = {.lex_state = 43, .external_lex_state = 1}, + [461] = {.lex_state = 43, .external_lex_state = 1}, + [462] = {.lex_state = 43, .external_lex_state = 1}, + [463] = {.lex_state = 43, .external_lex_state = 2}, + [464] = {.lex_state = 43, .external_lex_state = 1}, + [465] = {.lex_state = 43, .external_lex_state = 1}, + [466] = {.lex_state = 43, .external_lex_state = 1}, + [467] = {.lex_state = 43, .external_lex_state = 1}, + [468] = {.lex_state = 43, .external_lex_state = 1}, + [469] = {.lex_state = 43, .external_lex_state = 2}, + [470] = {.lex_state = 43, .external_lex_state = 1}, + [471] = {.lex_state = 43, .external_lex_state = 1}, + [472] = {.lex_state = 43, .external_lex_state = 1}, + [473] = {.lex_state = 43, .external_lex_state = 2}, + [474] = {.lex_state = 43, .external_lex_state = 1}, + [475] = {.lex_state = 43, .external_lex_state = 1}, + [476] = {.lex_state = 43, .external_lex_state = 1}, + [477] = {.lex_state = 43, .external_lex_state = 2}, + [478] = {.lex_state = 43, .external_lex_state = 1}, + [479] = {.lex_state = 43, .external_lex_state = 1}, + [480] = {.lex_state = 43, .external_lex_state = 2}, + [481] = {.lex_state = 43, .external_lex_state = 1}, [482] = {.lex_state = 8}, - [483] = {.lex_state = 41, .external_lex_state = 1}, - [484] = {.lex_state = 41, .external_lex_state = 1}, - [485] = {.lex_state = 41, .external_lex_state = 1}, - [486] = {.lex_state = 41, .external_lex_state = 1}, - [487] = {.lex_state = 41, .external_lex_state = 1}, - [488] = {.lex_state = 41, .external_lex_state = 1}, - [489] = {.lex_state = 41, .external_lex_state = 1}, - [490] = {.lex_state = 41, .external_lex_state = 1}, - [491] = {.lex_state = 41, .external_lex_state = 1}, - [492] = {.lex_state = 41, .external_lex_state = 2}, - [493] = {.lex_state = 41, .external_lex_state = 1}, - [494] = {.lex_state = 41, .external_lex_state = 1}, - [495] = {.lex_state = 41, .external_lex_state = 1}, - [496] = {.lex_state = 41, .external_lex_state = 2}, - [497] = {.lex_state = 41, .external_lex_state = 1}, - [498] = {.lex_state = 41, .external_lex_state = 2}, - [499] = {.lex_state = 41, .external_lex_state = 1}, - [500] = {.lex_state = 41, .external_lex_state = 1}, - [501] = {.lex_state = 41, .external_lex_state = 1}, - [502] = {.lex_state = 41, .external_lex_state = 1}, - [503] = {.lex_state = 41, .external_lex_state = 1}, - [504] = {.lex_state = 41, .external_lex_state = 1}, - [505] = {.lex_state = 41, .external_lex_state = 1}, - [506] = {.lex_state = 41, .external_lex_state = 1}, - [507] = {.lex_state = 41, .external_lex_state = 1}, + [483] = {.lex_state = 43, .external_lex_state = 1}, + [484] = {.lex_state = 43, .external_lex_state = 1}, + [485] = {.lex_state = 43, .external_lex_state = 1}, + [486] = {.lex_state = 43, .external_lex_state = 1}, + [487] = {.lex_state = 43, .external_lex_state = 1}, + [488] = {.lex_state = 43, .external_lex_state = 1}, + [489] = {.lex_state = 43, .external_lex_state = 1}, + [490] = {.lex_state = 43, .external_lex_state = 1}, + [491] = {.lex_state = 43, .external_lex_state = 1}, + [492] = {.lex_state = 43, .external_lex_state = 2}, + [493] = {.lex_state = 43, .external_lex_state = 1}, + [494] = {.lex_state = 43, .external_lex_state = 1}, + [495] = {.lex_state = 43, .external_lex_state = 1}, + [496] = {.lex_state = 43, .external_lex_state = 2}, + [497] = {.lex_state = 43, .external_lex_state = 1}, + [498] = {.lex_state = 43, .external_lex_state = 2}, + [499] = {.lex_state = 43, .external_lex_state = 1}, + [500] = {.lex_state = 43, .external_lex_state = 1}, + [501] = {.lex_state = 43, .external_lex_state = 1}, + [502] = {.lex_state = 43, .external_lex_state = 1}, + [503] = {.lex_state = 43, .external_lex_state = 1}, + [504] = {.lex_state = 43, .external_lex_state = 1}, + [505] = {.lex_state = 43, .external_lex_state = 1}, + [506] = {.lex_state = 43, .external_lex_state = 1}, + [507] = {.lex_state = 43, .external_lex_state = 1}, [508] = {.lex_state = 8}, - [509] = {.lex_state = 41, .external_lex_state = 1}, - [510] = {.lex_state = 41, .external_lex_state = 1}, - [511] = {.lex_state = 41, .external_lex_state = 1}, - [512] = {.lex_state = 41, .external_lex_state = 1}, - [513] = {.lex_state = 41, .external_lex_state = 1}, - [514] = {.lex_state = 41, .external_lex_state = 1}, - [515] = {.lex_state = 41, .external_lex_state = 1}, - [516] = {.lex_state = 41, .external_lex_state = 1}, - [517] = {.lex_state = 41, .external_lex_state = 1}, - [518] = {.lex_state = 43}, + [509] = {.lex_state = 43, .external_lex_state = 1}, + [510] = {.lex_state = 43, .external_lex_state = 1}, + [511] = {.lex_state = 43, .external_lex_state = 1}, + [512] = {.lex_state = 43, .external_lex_state = 1}, + [513] = {.lex_state = 43, .external_lex_state = 1}, + [514] = {.lex_state = 43, .external_lex_state = 1}, + [515] = {.lex_state = 43, .external_lex_state = 1}, + [516] = {.lex_state = 43, .external_lex_state = 1}, + [517] = {.lex_state = 43, .external_lex_state = 1}, + [518] = {.lex_state = 45}, [519] = {.lex_state = 8}, - [520] = {.lex_state = 41, .external_lex_state = 1}, - [521] = {.lex_state = 41, .external_lex_state = 1}, - [522] = {.lex_state = 41, .external_lex_state = 1}, - [523] = {.lex_state = 41, .external_lex_state = 1}, - [524] = {.lex_state = 41, .external_lex_state = 1}, - [525] = {.lex_state = 41, .external_lex_state = 1}, - [526] = {.lex_state = 41, .external_lex_state = 1}, - [527] = {.lex_state = 41, .external_lex_state = 1}, - [528] = {.lex_state = 8}, - [529] = {.lex_state = 41, .external_lex_state = 1}, - [530] = {.lex_state = 41, .external_lex_state = 1}, - [531] = {.lex_state = 41, .external_lex_state = 1}, - [532] = {.lex_state = 41, .external_lex_state = 1}, - [533] = {.lex_state = 41, .external_lex_state = 1}, - [534] = {.lex_state = 41, .external_lex_state = 2}, - [535] = {.lex_state = 41, .external_lex_state = 1}, - [536] = {.lex_state = 41, .external_lex_state = 1}, - [537] = {.lex_state = 41, .external_lex_state = 1}, - [538] = {.lex_state = 41, .external_lex_state = 1}, - [539] = {.lex_state = 41, .external_lex_state = 2}, - [540] = {.lex_state = 41, .external_lex_state = 1}, - [541] = {.lex_state = 41, .external_lex_state = 2}, - [542] = {.lex_state = 41, .external_lex_state = 1}, - [543] = {.lex_state = 41, .external_lex_state = 2}, - [544] = {.lex_state = 41, .external_lex_state = 1}, - [545] = {.lex_state = 8}, - [546] = {.lex_state = 41, .external_lex_state = 2}, - [547] = {.lex_state = 41, .external_lex_state = 2}, - [548] = {.lex_state = 41, .external_lex_state = 2}, - [549] = {.lex_state = 41, .external_lex_state = 2}, - [550] = {.lex_state = 41, .external_lex_state = 2}, - [551] = {.lex_state = 41, .external_lex_state = 2}, - [552] = {.lex_state = 8}, - [553] = {.lex_state = 8}, - [554] = {.lex_state = 41, .external_lex_state = 2}, - [555] = {.lex_state = 41, .external_lex_state = 2}, - [556] = {.lex_state = 41, .external_lex_state = 2}, - [557] = {.lex_state = 41, .external_lex_state = 1}, - [558] = {.lex_state = 8}, - [559] = {.lex_state = 0}, - [560] = {.lex_state = 41, .external_lex_state = 1}, - [561] = {.lex_state = 41, .external_lex_state = 1}, - [562] = {.lex_state = 41, .external_lex_state = 2}, - [563] = {.lex_state = 41, .external_lex_state = 2}, - [564] = {.lex_state = 41, .external_lex_state = 2}, - [565] = {.lex_state = 41, .external_lex_state = 1}, - [566] = {.lex_state = 41, .external_lex_state = 2}, - [567] = {.lex_state = 41, .external_lex_state = 2}, - [568] = {.lex_state = 41, .external_lex_state = 2}, - [569] = {.lex_state = 41, .external_lex_state = 1}, - [570] = {.lex_state = 41, .external_lex_state = 1}, - [571] = {.lex_state = 41, .external_lex_state = 2}, - [572] = {.lex_state = 41, .external_lex_state = 1}, - [573] = {.lex_state = 41, .external_lex_state = 2}, - [574] = {.lex_state = 41, .external_lex_state = 1}, + [520] = {.lex_state = 43, .external_lex_state = 1}, + [521] = {.lex_state = 43, .external_lex_state = 1}, + [522] = {.lex_state = 43, .external_lex_state = 1}, + [523] = {.lex_state = 43, .external_lex_state = 1}, + [524] = {.lex_state = 43, .external_lex_state = 1}, + [525] = {.lex_state = 43, .external_lex_state = 1}, + [526] = {.lex_state = 43, .external_lex_state = 1}, + [527] = {.lex_state = 43, .external_lex_state = 2}, + [528] = {.lex_state = 43, .external_lex_state = 1}, + [529] = {.lex_state = 43, .external_lex_state = 2}, + [530] = {.lex_state = 8}, + [531] = {.lex_state = 43, .external_lex_state = 1}, + [532] = {.lex_state = 43, .external_lex_state = 1}, + [533] = {.lex_state = 43, .external_lex_state = 1}, + [534] = {.lex_state = 43, .external_lex_state = 1}, + [535] = {.lex_state = 43, .external_lex_state = 1}, + [536] = {.lex_state = 43, .external_lex_state = 2}, + [537] = {.lex_state = 43, .external_lex_state = 1}, + [538] = {.lex_state = 43, .external_lex_state = 1}, + [539] = {.lex_state = 43, .external_lex_state = 1}, + [540] = {.lex_state = 43, .external_lex_state = 1}, + [541] = {.lex_state = 43, .external_lex_state = 2}, + [542] = {.lex_state = 43, .external_lex_state = 2}, + [543] = {.lex_state = 43, .external_lex_state = 1}, + [544] = {.lex_state = 43, .external_lex_state = 2}, + [545] = {.lex_state = 43, .external_lex_state = 1}, + [546] = {.lex_state = 43, .external_lex_state = 1}, + [547] = {.lex_state = 8}, + [548] = {.lex_state = 43, .external_lex_state = 2}, + [549] = {.lex_state = 43, .external_lex_state = 2}, + [550] = {.lex_state = 43, .external_lex_state = 2}, + [551] = {.lex_state = 43, .external_lex_state = 2}, + [552] = {.lex_state = 43, .external_lex_state = 2}, + [553] = {.lex_state = 43, .external_lex_state = 2}, + [554] = {.lex_state = 8}, + [555] = {.lex_state = 8}, + [556] = {.lex_state = 43, .external_lex_state = 2}, + [557] = {.lex_state = 43, .external_lex_state = 2}, + [558] = {.lex_state = 43, .external_lex_state = 2}, + [559] = {.lex_state = 43, .external_lex_state = 1}, + [560] = {.lex_state = 8}, + [561] = {.lex_state = 0}, + [562] = {.lex_state = 43, .external_lex_state = 2}, + [563] = {.lex_state = 43, .external_lex_state = 1}, + [564] = {.lex_state = 43, .external_lex_state = 1}, + [565] = {.lex_state = 43, .external_lex_state = 2}, + [566] = {.lex_state = 43, .external_lex_state = 2}, + [567] = {.lex_state = 43, .external_lex_state = 2}, + [568] = {.lex_state = 43, .external_lex_state = 1}, + [569] = {.lex_state = 43, .external_lex_state = 2}, + [570] = {.lex_state = 43, .external_lex_state = 2}, + [571] = {.lex_state = 43, .external_lex_state = 1}, + [572] = {.lex_state = 43, .external_lex_state = 1}, + [573] = {.lex_state = 43, .external_lex_state = 2}, + [574] = {.lex_state = 43, .external_lex_state = 2}, [575] = {.lex_state = 8}, - [576] = {.lex_state = 41, .external_lex_state = 2}, - [577] = {.lex_state = 41, .external_lex_state = 2}, - [578] = {.lex_state = 41, .external_lex_state = 2}, - [579] = {.lex_state = 41, .external_lex_state = 1}, - [580] = {.lex_state = 41, .external_lex_state = 2}, - [581] = {.lex_state = 41, .external_lex_state = 2}, - [582] = {.lex_state = 41, .external_lex_state = 1}, + [576] = {.lex_state = 43, .external_lex_state = 2}, + [577] = {.lex_state = 43, .external_lex_state = 2}, + [578] = {.lex_state = 43, .external_lex_state = 2}, + [579] = {.lex_state = 43, .external_lex_state = 1}, + [580] = {.lex_state = 43, .external_lex_state = 2}, + [581] = {.lex_state = 43, .external_lex_state = 2}, + [582] = {.lex_state = 43, .external_lex_state = 1}, [583] = {.lex_state = 8}, - [584] = {.lex_state = 41, .external_lex_state = 2}, - [585] = {.lex_state = 41, .external_lex_state = 1}, - [586] = {.lex_state = 41, .external_lex_state = 2}, - [587] = {.lex_state = 41, .external_lex_state = 2}, - [588] = {.lex_state = 41, .external_lex_state = 1}, - [589] = {.lex_state = 41, .external_lex_state = 1}, - [590] = {.lex_state = 41, .external_lex_state = 1}, - [591] = {.lex_state = 41, .external_lex_state = 1}, - [592] = {.lex_state = 41, .external_lex_state = 1}, - [593] = {.lex_state = 41, .external_lex_state = 1}, - [594] = {.lex_state = 0}, - [595] = {.lex_state = 41, .external_lex_state = 1}, - [596] = {.lex_state = 41, .external_lex_state = 1}, - [597] = {.lex_state = 41, .external_lex_state = 1}, - [598] = {.lex_state = 8}, - [599] = {.lex_state = 41, .external_lex_state = 2}, - [600] = {.lex_state = 41, .external_lex_state = 1}, - [601] = {.lex_state = 41, .external_lex_state = 1}, - [602] = {.lex_state = 41, .external_lex_state = 2}, - [603] = {.lex_state = 41, .external_lex_state = 2}, - [604] = {.lex_state = 41, .external_lex_state = 2}, - [605] = {.lex_state = 41, .external_lex_state = 2}, - [606] = {.lex_state = 41, .external_lex_state = 1}, - [607] = {.lex_state = 41, .external_lex_state = 1}, - [608] = {.lex_state = 41, .external_lex_state = 1}, - [609] = {.lex_state = 41, .external_lex_state = 2}, - [610] = {.lex_state = 41, .external_lex_state = 1}, - [611] = {.lex_state = 0}, - [612] = {.lex_state = 0}, - [613] = {.lex_state = 41, .external_lex_state = 2}, - [614] = {.lex_state = 8}, - [615] = {.lex_state = 8}, - [616] = {.lex_state = 41, .external_lex_state = 2}, + [584] = {.lex_state = 43, .external_lex_state = 2}, + [585] = {.lex_state = 43, .external_lex_state = 2}, + [586] = {.lex_state = 43, .external_lex_state = 2}, + [587] = {.lex_state = 43, .external_lex_state = 1}, + [588] = {.lex_state = 43, .external_lex_state = 1}, + [589] = {.lex_state = 43, .external_lex_state = 1}, + [590] = {.lex_state = 43, .external_lex_state = 1}, + [591] = {.lex_state = 43, .external_lex_state = 1}, + [592] = {.lex_state = 43, .external_lex_state = 1}, + [593] = {.lex_state = 43, .external_lex_state = 1}, + [594] = {.lex_state = 43, .external_lex_state = 1}, + [595] = {.lex_state = 43, .external_lex_state = 1}, + [596] = {.lex_state = 43, .external_lex_state = 1}, + [597] = {.lex_state = 43, .external_lex_state = 1}, + [598] = {.lex_state = 0}, + [599] = {.lex_state = 43, .external_lex_state = 1}, + [600] = {.lex_state = 43, .external_lex_state = 2}, + [601] = {.lex_state = 43, .external_lex_state = 2}, + [602] = {.lex_state = 43, .external_lex_state = 1}, + [603] = {.lex_state = 8}, + [604] = {.lex_state = 43, .external_lex_state = 2}, + [605] = {.lex_state = 43, .external_lex_state = 2}, + [606] = {.lex_state = 43, .external_lex_state = 1}, + [607] = {.lex_state = 43, .external_lex_state = 1}, + [608] = {.lex_state = 43, .external_lex_state = 1}, + [609] = {.lex_state = 43, .external_lex_state = 1}, + [610] = {.lex_state = 43, .external_lex_state = 1}, + [611] = {.lex_state = 43, .external_lex_state = 2}, + [612] = {.lex_state = 43, .external_lex_state = 2}, + [613] = {.lex_state = 45}, + [614] = {.lex_state = 43, .external_lex_state = 2}, + [615] = {.lex_state = 43, .external_lex_state = 2}, + [616] = {.lex_state = 8}, [617] = {.lex_state = 0}, - [618] = {.lex_state = 0}, - [619] = {.lex_state = 41, .external_lex_state = 2}, - [620] = {.lex_state = 8}, + [618] = {.lex_state = 43, .external_lex_state = 2}, + [619] = {.lex_state = 8}, + [620] = {.lex_state = 43, .external_lex_state = 2}, [621] = {.lex_state = 0}, - [622] = {.lex_state = 41, .external_lex_state = 2}, - [623] = {.lex_state = 43}, - [624] = {.lex_state = 41, .external_lex_state = 2}, - [625] = {.lex_state = 41, .external_lex_state = 2}, - [626] = {.lex_state = 41, .external_lex_state = 2}, + [622] = {.lex_state = 0}, + [623] = {.lex_state = 8}, + [624] = {.lex_state = 0}, + [625] = {.lex_state = 0}, + [626] = {.lex_state = 43, .external_lex_state = 2}, [627] = {.lex_state = 8}, - [628] = {.lex_state = 8}, + [628] = {.lex_state = 9}, [629] = {.lex_state = 8}, [630] = {.lex_state = 8}, - [631] = {.lex_state = 43}, - [632] = {.lex_state = 43}, - [633] = {.lex_state = 8}, + [631] = {.lex_state = 45}, + [632] = {.lex_state = 8}, + [633] = {.lex_state = 9}, [634] = {.lex_state = 8}, - [635] = {.lex_state = 0}, - [636] = {.lex_state = 0}, + [635] = {.lex_state = 8}, + [636] = {.lex_state = 45}, [637] = {.lex_state = 0}, [638] = {.lex_state = 0}, [639] = {.lex_state = 0}, [640] = {.lex_state = 0}, - [641] = {.lex_state = 0}, + [641] = {.lex_state = 9}, [642] = {.lex_state = 0}, [643] = {.lex_state = 0}, - [644] = {.lex_state = 43}, - [645] = {.lex_state = 43}, - [646] = {.lex_state = 43}, - [647] = {.lex_state = 43}, - [648] = {.lex_state = 43}, - [649] = {.lex_state = 8}, - [650] = {.lex_state = 43}, + [644] = {.lex_state = 0}, + [645] = {.lex_state = 0}, + [646] = {.lex_state = 0}, + [647] = {.lex_state = 45}, + [648] = {.lex_state = 45}, + [649] = {.lex_state = 45}, + [650] = {.lex_state = 45}, [651] = {.lex_state = 8}, - [652] = {.lex_state = 8}, + [652] = {.lex_state = 0}, [653] = {.lex_state = 0}, - [654] = {.lex_state = 43}, - [655] = {.lex_state = 0}, - [656] = {.lex_state = 0}, - [657] = {.lex_state = 0}, + [654] = {.lex_state = 0}, + [655] = {.lex_state = 45}, + [656] = {.lex_state = 45}, + [657] = {.lex_state = 45}, [658] = {.lex_state = 0}, [659] = {.lex_state = 0}, [660] = {.lex_state = 0}, - [661] = {.lex_state = 41}, - [662] = {.lex_state = 10}, + [661] = {.lex_state = 43}, + [662] = {.lex_state = 11}, [663] = {.lex_state = 0}, [664] = {.lex_state = 0}, - [665] = {.lex_state = 10}, - [666] = {.lex_state = 0}, - [667] = {.lex_state = 41}, - [668] = {.lex_state = 41}, + [665] = {.lex_state = 43}, + [666] = {.lex_state = 11}, + [667] = {.lex_state = 0}, + [668] = {.lex_state = 43}, [669] = {.lex_state = 0}, - [670] = {.lex_state = 10}, + [670] = {.lex_state = 11}, [671] = {.lex_state = 0}, [672] = {.lex_state = 0}, [673] = {.lex_state = 0}, - [674] = {.lex_state = 10}, - [675] = {.lex_state = 41}, + [674] = {.lex_state = 11}, + [675] = {.lex_state = 43}, [676] = {.lex_state = 0}, [677] = {.lex_state = 0}, [678] = {.lex_state = 0}, @@ -6307,11 +6358,11 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [681] = {.lex_state = 0}, [682] = {.lex_state = 0}, [683] = {.lex_state = 0}, - [684] = {.lex_state = 41}, - [685] = {.lex_state = 41}, - [686] = {.lex_state = 8}, - [687] = {.lex_state = 41}, - [688] = {.lex_state = 41}, + [684] = {.lex_state = 0}, + [685] = {.lex_state = 43}, + [686] = {.lex_state = 43}, + [687] = {.lex_state = 43}, + [688] = {.lex_state = 43}, [689] = {.lex_state = 0}, [690] = {.lex_state = 0}, [691] = {.lex_state = 0}, @@ -6329,7 +6380,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [703] = {.lex_state = 0}, [704] = {.lex_state = 0}, [705] = {.lex_state = 0}, - [706] = {.lex_state = 0}, + [706] = {.lex_state = 45}, [707] = {.lex_state = 0}, [708] = {.lex_state = 0}, [709] = {.lex_state = 0}, @@ -6377,22 +6428,22 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [751] = {.lex_state = 0}, [752] = {.lex_state = 0}, [753] = {.lex_state = 0}, - [754] = {.lex_state = 0}, + [754] = {.lex_state = 8}, [755] = {.lex_state = 0}, - [756] = {.lex_state = 8}, + [756] = {.lex_state = 0}, [757] = {.lex_state = 0}, [758] = {.lex_state = 0}, [759] = {.lex_state = 0}, [760] = {.lex_state = 0}, [761] = {.lex_state = 0}, [762] = {.lex_state = 0}, - [763] = {.lex_state = 10}, - [764] = {.lex_state = 41}, - [765] = {.lex_state = 0}, + [763] = {.lex_state = 0}, + [764] = {.lex_state = 0}, + [765] = {.lex_state = 11}, [766] = {.lex_state = 0}, - [767] = {.lex_state = 41}, - [768] = {.lex_state = 0}, - [769] = {.lex_state = 10}, + [767] = {.lex_state = 0}, + [768] = {.lex_state = 11}, + [769] = {.lex_state = 0}, [770] = {.lex_state = 0}, [771] = {.lex_state = 0}, [772] = {.lex_state = 0}, @@ -6402,18 +6453,18 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [776] = {.lex_state = 0}, [777] = {.lex_state = 0}, [778] = {.lex_state = 0}, - [779] = {.lex_state = 0}, + [779] = {.lex_state = 11}, [780] = {.lex_state = 0}, [781] = {.lex_state = 0}, - [782] = {.lex_state = 10}, + [782] = {.lex_state = 0}, [783] = {.lex_state = 0}, - [784] = {.lex_state = 0}, + [784] = {.lex_state = 43}, [785] = {.lex_state = 0}, [786] = {.lex_state = 0}, - [787] = {.lex_state = 0}, + [787] = {.lex_state = 11}, [788] = {.lex_state = 0}, [789] = {.lex_state = 0}, - [790] = {.lex_state = 10}, + [790] = {.lex_state = 0}, [791] = {.lex_state = 0}, [792] = {.lex_state = 0}, [793] = {.lex_state = 0}, @@ -6423,967 +6474,960 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [797] = {.lex_state = 0}, [798] = {.lex_state = 0}, [799] = {.lex_state = 0}, - [800] = {.lex_state = 0}, - [801] = {.lex_state = 0}, - [802] = {.lex_state = 0}, + [800] = {.lex_state = 8}, + [801] = {.lex_state = 8}, + [802] = {.lex_state = 43}, [803] = {.lex_state = 0}, - [804] = {.lex_state = 0}, + [804] = {.lex_state = 43}, [805] = {.lex_state = 43}, - [806] = {.lex_state = 41}, - [807] = {.lex_state = 0}, - [808] = {.lex_state = 0}, - [809] = {.lex_state = 8}, + [806] = {.lex_state = 45}, + [807] = {.lex_state = 43}, + [808] = {.lex_state = 8}, + [809] = {.lex_state = 0}, [810] = {.lex_state = 0}, - [811] = {.lex_state = 41}, - [812] = {.lex_state = 41}, - [813] = {.lex_state = 8}, + [811] = {.lex_state = 8}, + [812] = {.lex_state = 0}, + [813] = {.lex_state = 43}, [814] = {.lex_state = 43}, - [815] = {.lex_state = 0}, - [816] = {.lex_state = 41}, + [815] = {.lex_state = 43}, + [816] = {.lex_state = 43}, [817] = {.lex_state = 8}, - [818] = {.lex_state = 41}, - [819] = {.lex_state = 8}, - [820] = {.lex_state = 41}, - [821] = {.lex_state = 41}, - [822] = {.lex_state = 41}, - [823] = {.lex_state = 8}, - [824] = {.lex_state = 41}, - [825] = {.lex_state = 41}, - [826] = {.lex_state = 43}, - [827] = {.lex_state = 41}, - [828] = {.lex_state = 41}, - [829] = {.lex_state = 16}, - [830] = {.lex_state = 41}, - [831] = {.lex_state = 16}, - [832] = {.lex_state = 41}, - [833] = {.lex_state = 41}, - [834] = {.lex_state = 41}, - [835] = {.lex_state = 41}, - [836] = {.lex_state = 41}, + [818] = {.lex_state = 45}, + [819] = {.lex_state = 45}, + [820] = {.lex_state = 45}, + [821] = {.lex_state = 45}, + [822] = {.lex_state = 43}, + [823] = {.lex_state = 43}, + [824] = {.lex_state = 43}, + [825] = {.lex_state = 0}, + [826] = {.lex_state = 22}, + [827] = {.lex_state = 43}, + [828] = {.lex_state = 43}, + [829] = {.lex_state = 22}, + [830] = {.lex_state = 43}, + [831] = {.lex_state = 43}, + [832] = {.lex_state = 43}, + [833] = {.lex_state = 43}, + [834] = {.lex_state = 43}, + [835] = {.lex_state = 0}, + [836] = {.lex_state = 43}, [837] = {.lex_state = 43}, [838] = {.lex_state = 0}, - [839] = {.lex_state = 41}, - [840] = {.lex_state = 0}, - [841] = {.lex_state = 41}, - [842] = {.lex_state = 41}, - [843] = {.lex_state = 41}, - [844] = {.lex_state = 41}, - [845] = {.lex_state = 41}, - [846] = {.lex_state = 41}, + [839] = {.lex_state = 43}, + [840] = {.lex_state = 43}, + [841] = {.lex_state = 43}, + [842] = {.lex_state = 43}, + [843] = {.lex_state = 43}, + [844] = {.lex_state = 0}, + [845] = {.lex_state = 43}, + [846] = {.lex_state = 43}, [847] = {.lex_state = 0}, - [848] = {.lex_state = 41}, - [849] = {.lex_state = 0}, - [850] = {.lex_state = 41}, - [851] = {.lex_state = 0}, - [852] = {.lex_state = 41}, - [853] = {.lex_state = 41}, - [854] = {.lex_state = 41}, - [855] = {.lex_state = 41}, - [856] = {.lex_state = 41}, - [857] = {.lex_state = 41}, - [858] = {.lex_state = 41}, - [859] = {.lex_state = 41}, - [860] = {.lex_state = 41}, - [861] = {.lex_state = 41}, - [862] = {.lex_state = 8, .external_lex_state = 3}, - [863] = {.lex_state = 41}, - [864] = {.lex_state = 8, .external_lex_state = 3}, - [865] = {.lex_state = 41}, - [866] = {.lex_state = 41}, - [867] = {.lex_state = 41}, - [868] = {.lex_state = 41}, + [848] = {.lex_state = 8, .external_lex_state = 3}, + [849] = {.lex_state = 43}, + [850] = {.lex_state = 43}, + [851] = {.lex_state = 43}, + [852] = {.lex_state = 43}, + [853] = {.lex_state = 43}, + [854] = {.lex_state = 43}, + [855] = {.lex_state = 43}, + [856] = {.lex_state = 43}, + [857] = {.lex_state = 8, .external_lex_state = 3}, + [858] = {.lex_state = 43}, + [859] = {.lex_state = 8, .external_lex_state = 3}, + [860] = {.lex_state = 43}, + [861] = {.lex_state = 43}, + [862] = {.lex_state = 43}, + [863] = {.lex_state = 43}, + [864] = {.lex_state = 0}, + [865] = {.lex_state = 43}, + [866] = {.lex_state = 43}, + [867] = {.lex_state = 43}, + [868] = {.lex_state = 43}, [869] = {.lex_state = 0}, - [870] = {.lex_state = 41}, - [871] = {.lex_state = 41}, + [870] = {.lex_state = 43}, + [871] = {.lex_state = 43}, [872] = {.lex_state = 0}, - [873] = {.lex_state = 41}, - [874] = {.lex_state = 41}, - [875] = {.lex_state = 41}, - [876] = {.lex_state = 41}, - [877] = {.lex_state = 41}, - [878] = {.lex_state = 41}, - [879] = {.lex_state = 0}, - [880] = {.lex_state = 41}, - [881] = {.lex_state = 0}, - [882] = {.lex_state = 41}, - [883] = {.lex_state = 0}, + [873] = {.lex_state = 43}, + [874] = {.lex_state = 0}, + [875] = {.lex_state = 43}, + [876] = {.lex_state = 0}, + [877] = {.lex_state = 0}, + [878] = {.lex_state = 43}, + [879] = {.lex_state = 43}, + [880] = {.lex_state = 43}, + [881] = {.lex_state = 43}, + [882] = {.lex_state = 43}, + [883] = {.lex_state = 43}, [884] = {.lex_state = 0}, - [885] = {.lex_state = 41}, - [886] = {.lex_state = 0}, - [887] = {.lex_state = 41}, - [888] = {.lex_state = 41}, - [889] = {.lex_state = 41}, - [890] = {.lex_state = 41}, - [891] = {.lex_state = 0}, - [892] = {.lex_state = 0}, - [893] = {.lex_state = 0}, - [894] = {.lex_state = 41}, - [895] = {.lex_state = 41}, - [896] = {.lex_state = 41}, - [897] = {.lex_state = 0}, - [898] = {.lex_state = 41}, - [899] = {.lex_state = 41}, - [900] = {.lex_state = 41}, - [901] = {.lex_state = 41}, - [902] = {.lex_state = 41}, - [903] = {.lex_state = 41}, - [904] = {.lex_state = 41}, - [905] = {.lex_state = 41}, - [906] = {.lex_state = 0}, - [907] = {.lex_state = 41}, - [908] = {.lex_state = 0}, - [909] = {.lex_state = 0}, - [910] = {.lex_state = 41}, - [911] = {.lex_state = 41}, - [912] = {.lex_state = 0}, - [913] = {.lex_state = 41}, - [914] = {.lex_state = 0}, - [915] = {.lex_state = 41}, - [916] = {.lex_state = 41}, - [917] = {.lex_state = 41}, - [918] = {.lex_state = 41}, - [919] = {.lex_state = 41}, - [920] = {.lex_state = 41}, - [921] = {.lex_state = 41}, - [922] = {.lex_state = 8, .external_lex_state = 3}, - [923] = {.lex_state = 41}, - [924] = {.lex_state = 41}, - [925] = {.lex_state = 41}, - [926] = {.lex_state = 41}, - [927] = {.lex_state = 41}, - [928] = {.lex_state = 41}, - [929] = {.lex_state = 41}, - [930] = {.lex_state = 41}, - [931] = {.lex_state = 41}, - [932] = {.lex_state = 41}, - [933] = {.lex_state = 41}, - [934] = {.lex_state = 41}, - [935] = {.lex_state = 41}, - [936] = {.lex_state = 41}, - [937] = {.lex_state = 41}, - [938] = {.lex_state = 41}, - [939] = {.lex_state = 41}, - [940] = {.lex_state = 8, .external_lex_state = 3}, - [941] = {.lex_state = 41}, - [942] = {.lex_state = 8, .external_lex_state = 3}, - [943] = {.lex_state = 0}, - [944] = {.lex_state = 0}, - [945] = {.lex_state = 8, .external_lex_state = 3}, - [946] = {.lex_state = 0}, + [885] = {.lex_state = 0}, + [886] = {.lex_state = 43}, + [887] = {.lex_state = 0}, + [888] = {.lex_state = 0}, + [889] = {.lex_state = 43}, + [890] = {.lex_state = 43}, + [891] = {.lex_state = 43}, + [892] = {.lex_state = 43}, + [893] = {.lex_state = 43}, + [894] = {.lex_state = 43}, + [895] = {.lex_state = 43}, + [896] = {.lex_state = 0}, + [897] = {.lex_state = 43}, + [898] = {.lex_state = 0}, + [899] = {.lex_state = 0}, + [900] = {.lex_state = 43}, + [901] = {.lex_state = 43}, + [902] = {.lex_state = 43}, + [903] = {.lex_state = 0}, + [904] = {.lex_state = 43}, + [905] = {.lex_state = 43}, + [906] = {.lex_state = 43}, + [907] = {.lex_state = 43}, + [908] = {.lex_state = 43}, + [909] = {.lex_state = 43}, + [910] = {.lex_state = 43}, + [911] = {.lex_state = 43}, + [912] = {.lex_state = 43}, + [913] = {.lex_state = 43}, + [914] = {.lex_state = 43}, + [915] = {.lex_state = 43}, + [916] = {.lex_state = 43}, + [917] = {.lex_state = 0}, + [918] = {.lex_state = 43}, + [919] = {.lex_state = 43}, + [920] = {.lex_state = 43}, + [921] = {.lex_state = 43}, + [922] = {.lex_state = 43}, + [923] = {.lex_state = 43}, + [924] = {.lex_state = 43}, + [925] = {.lex_state = 43}, + [926] = {.lex_state = 0}, + [927] = {.lex_state = 43}, + [928] = {.lex_state = 43}, + [929] = {.lex_state = 43}, + [930] = {.lex_state = 43}, + [931] = {.lex_state = 43}, + [932] = {.lex_state = 43}, + [933] = {.lex_state = 43}, + [934] = {.lex_state = 43}, + [935] = {.lex_state = 8, .external_lex_state = 3}, + [936] = {.lex_state = 8, .external_lex_state = 3}, + [937] = {.lex_state = 43}, + [938] = {.lex_state = 0}, + [939] = {.lex_state = 0}, + [940] = {.lex_state = 43}, + [941] = {.lex_state = 0}, + [942] = {.lex_state = 43}, + [943] = {.lex_state = 43}, + [944] = {.lex_state = 43}, + [945] = {.lex_state = 0}, + [946] = {.lex_state = 43}, [947] = {.lex_state = 0}, - [948] = {.lex_state = 0}, - [949] = {.lex_state = 41}, - [950] = {.lex_state = 41}, - [951] = {.lex_state = 41}, - [952] = {.lex_state = 0}, - [953] = {.lex_state = 41}, + [948] = {.lex_state = 43}, + [949] = {.lex_state = 0}, + [950] = {.lex_state = 0}, + [951] = {.lex_state = 0}, + [952] = {.lex_state = 43}, + [953] = {.lex_state = 0}, [954] = {.lex_state = 0}, - [955] = {.lex_state = 41}, - [956] = {.lex_state = 41}, - [957] = {.lex_state = 41}, - [958] = {.lex_state = 0}, - [959] = {.lex_state = 0}, + [955] = {.lex_state = 0}, + [956] = {.lex_state = 8, .external_lex_state = 3}, + [957] = {.lex_state = 0}, + [958] = {.lex_state = 43}, + [959] = {.lex_state = 43}, [960] = {.lex_state = 0}, - [961] = {.lex_state = 41}, - [962] = {.lex_state = 0}, - [963] = {.lex_state = 0}, + [961] = {.lex_state = 0}, + [962] = {.lex_state = 43}, + [963] = {.lex_state = 43}, [964] = {.lex_state = 0}, - [965] = {.lex_state = 41}, - [966] = {.lex_state = 0}, - [967] = {.lex_state = 41}, - [968] = {.lex_state = 41}, - [969] = {.lex_state = 41}, - [970] = {.lex_state = 0}, - [971] = {.lex_state = 0}, - [972] = {.lex_state = 9}, - [973] = {.lex_state = 9}, - [974] = {.lex_state = 9}, - [975] = {.lex_state = 9}, - [976] = {.lex_state = 9}, - [977] = {.lex_state = 9}, - [978] = {.lex_state = 41}, - [979] = {.lex_state = 9}, - [980] = {.lex_state = 41}, - [981] = {.lex_state = 9}, - [982] = {.lex_state = 9}, - [983] = {.lex_state = 41}, - [984] = {.lex_state = 8, .external_lex_state = 3}, - [985] = {.lex_state = 9}, - [986] = {.lex_state = 9}, - [987] = {.lex_state = 9}, - [988] = {.lex_state = 9}, - [989] = {.lex_state = 9}, - [990] = {.lex_state = 9}, - [991] = {.lex_state = 41}, - [992] = {.lex_state = 9}, - [993] = {.lex_state = 41}, - [994] = {.lex_state = 41}, - [995] = {.lex_state = 41}, - [996] = {.lex_state = 41}, - [997] = {.lex_state = 41}, - [998] = {.lex_state = 41}, - [999] = {.lex_state = 41}, - [1000] = {.lex_state = 41}, - [1001] = {.lex_state = 41}, - [1002] = {.lex_state = 41}, - [1003] = {.lex_state = 41}, - [1004] = {.lex_state = 41}, - [1005] = {.lex_state = 41}, - [1006] = {.lex_state = 41}, - [1007] = {.lex_state = 41}, - [1008] = {.lex_state = 41}, - [1009] = {.lex_state = 8, .external_lex_state = 3}, - [1010] = {.lex_state = 41}, - [1011] = {.lex_state = 41}, - [1012] = {.lex_state = 41}, - [1013] = {.lex_state = 41}, - [1014] = {.lex_state = 41}, - [1015] = {.lex_state = 41}, - [1016] = {.lex_state = 41}, - [1017] = {.lex_state = 41}, - [1018] = {.lex_state = 8}, - [1019] = {.lex_state = 41}, - [1020] = {.lex_state = 41}, - [1021] = {.lex_state = 41}, - [1022] = {.lex_state = 41}, - [1023] = {.lex_state = 41}, - [1024] = {.lex_state = 41}, - [1025] = {.lex_state = 41}, - [1026] = {.lex_state = 41}, - [1027] = {.lex_state = 41}, - [1028] = {.lex_state = 41}, - [1029] = {.lex_state = 41}, - [1030] = {.lex_state = 41}, - [1031] = {.lex_state = 41}, - [1032] = {.lex_state = 41}, - [1033] = {.lex_state = 0}, - [1034] = {.lex_state = 41}, + [965] = {.lex_state = 0}, + [966] = {.lex_state = 10}, + [967] = {.lex_state = 10}, + [968] = {.lex_state = 10}, + [969] = {.lex_state = 43}, + [970] = {.lex_state = 10}, + [971] = {.lex_state = 10}, + [972] = {.lex_state = 10}, + [973] = {.lex_state = 10}, + [974] = {.lex_state = 43}, + [975] = {.lex_state = 10}, + [976] = {.lex_state = 10}, + [977] = {.lex_state = 10}, + [978] = {.lex_state = 10}, + [979] = {.lex_state = 10}, + [980] = {.lex_state = 10}, + [981] = {.lex_state = 10}, + [982] = {.lex_state = 43}, + [983] = {.lex_state = 8, .external_lex_state = 3}, + [984] = {.lex_state = 43}, + [985] = {.lex_state = 10}, + [986] = {.lex_state = 10}, + [987] = {.lex_state = 43}, + [988] = {.lex_state = 0}, + [989] = {.lex_state = 43}, + [990] = {.lex_state = 43}, + [991] = {.lex_state = 43}, + [992] = {.lex_state = 43}, + [993] = {.lex_state = 43}, + [994] = {.lex_state = 43}, + [995] = {.lex_state = 43}, + [996] = {.lex_state = 43}, + [997] = {.lex_state = 43}, + [998] = {.lex_state = 8, .external_lex_state = 3}, + [999] = {.lex_state = 43}, + [1000] = {.lex_state = 43}, + [1001] = {.lex_state = 43}, + [1002] = {.lex_state = 43}, + [1003] = {.lex_state = 43}, + [1004] = {.lex_state = 43}, + [1005] = {.lex_state = 43}, + [1006] = {.lex_state = 43}, + [1007] = {.lex_state = 43}, + [1008] = {.lex_state = 43}, + [1009] = {.lex_state = 43}, + [1010] = {.lex_state = 43}, + [1011] = {.lex_state = 43}, + [1012] = {.lex_state = 43}, + [1013] = {.lex_state = 43}, + [1014] = {.lex_state = 43}, + [1015] = {.lex_state = 43}, + [1016] = {.lex_state = 43}, + [1017] = {.lex_state = 43}, + [1018] = {.lex_state = 43}, + [1019] = {.lex_state = 43}, + [1020] = {.lex_state = 43}, + [1021] = {.lex_state = 43}, + [1022] = {.lex_state = 43, .external_lex_state = 3}, + [1023] = {.lex_state = 43}, + [1024] = {.lex_state = 43}, + [1025] = {.lex_state = 43}, + [1026] = {.lex_state = 43}, + [1027] = {.lex_state = 43}, + [1028] = {.lex_state = 43}, + [1029] = {.lex_state = 43}, + [1030] = {.lex_state = 8}, + [1031] = {.lex_state = 43}, + [1032] = {.lex_state = 43}, + [1033] = {.lex_state = 43}, + [1034] = {.lex_state = 43}, [1035] = {.lex_state = 8}, - [1036] = {.lex_state = 41}, - [1037] = {.lex_state = 41, .external_lex_state = 3}, - [1038] = {.lex_state = 41}, - [1039] = {.lex_state = 41}, - [1040] = {.lex_state = 41}, - [1041] = {.lex_state = 41}, - [1042] = {.lex_state = 41}, - [1043] = {.lex_state = 41}, - [1044] = {.lex_state = 41}, - [1045] = {.lex_state = 41}, - [1046] = {.lex_state = 41}, - [1047] = {.lex_state = 41}, - [1048] = {.lex_state = 41}, - [1049] = {.lex_state = 41}, - [1050] = {.lex_state = 41}, - [1051] = {.lex_state = 8}, - [1052] = {.lex_state = 41}, - [1053] = {.lex_state = 41}, - [1054] = {.lex_state = 41}, - [1055] = {.lex_state = 41}, - [1056] = {.lex_state = 41}, - [1057] = {.lex_state = 41}, - [1058] = {.lex_state = 41}, - [1059] = {.lex_state = 41}, - [1060] = {.lex_state = 41}, - [1061] = {.lex_state = 41}, - [1062] = {.lex_state = 16}, - [1063] = {.lex_state = 41}, - [1064] = {.lex_state = 41}, - [1065] = {.lex_state = 41}, - [1066] = {.lex_state = 41}, - [1067] = {.lex_state = 0}, - [1068] = {.lex_state = 41}, - [1069] = {.lex_state = 41}, - [1070] = {.lex_state = 41}, - [1071] = {.lex_state = 16}, - [1072] = {.lex_state = 8, .external_lex_state = 3}, - [1073] = {.lex_state = 16}, - [1074] = {.lex_state = 41}, - [1075] = {.lex_state = 16}, - [1076] = {.lex_state = 16}, - [1077] = {.lex_state = 16}, - [1078] = {.lex_state = 16}, - [1079] = {.lex_state = 16}, - [1080] = {.lex_state = 41}, - [1081] = {.lex_state = 41, .external_lex_state = 3}, - [1082] = {.lex_state = 41, .external_lex_state = 3}, - [1083] = {.lex_state = 16}, - [1084] = {.lex_state = 41}, - [1085] = {.lex_state = 41}, + [1036] = {.lex_state = 43}, + [1037] = {.lex_state = 43}, + [1038] = {.lex_state = 43}, + [1039] = {.lex_state = 43}, + [1040] = {.lex_state = 43}, + [1041] = {.lex_state = 43}, + [1042] = {.lex_state = 43}, + [1043] = {.lex_state = 43}, + [1044] = {.lex_state = 43}, + [1045] = {.lex_state = 8}, + [1046] = {.lex_state = 43}, + [1047] = {.lex_state = 43}, + [1048] = {.lex_state = 43}, + [1049] = {.lex_state = 43}, + [1050] = {.lex_state = 43}, + [1051] = {.lex_state = 43}, + [1052] = {.lex_state = 43}, + [1053] = {.lex_state = 43}, + [1054] = {.lex_state = 0}, + [1055] = {.lex_state = 43}, + [1056] = {.lex_state = 43}, + [1057] = {.lex_state = 9}, + [1058] = {.lex_state = 43}, + [1059] = {.lex_state = 43}, + [1060] = {.lex_state = 43}, + [1061] = {.lex_state = 43}, + [1062] = {.lex_state = 43}, + [1063] = {.lex_state = 43}, + [1064] = {.lex_state = 43}, + [1065] = {.lex_state = 22}, + [1066] = {.lex_state = 8}, + [1067] = {.lex_state = 22}, + [1068] = {.lex_state = 43}, + [1069] = {.lex_state = 8, .external_lex_state = 3}, + [1070] = {.lex_state = 8}, + [1071] = {.lex_state = 43}, + [1072] = {.lex_state = 22}, + [1073] = {.lex_state = 8}, + [1074] = {.lex_state = 43, .external_lex_state = 3}, + [1075] = {.lex_state = 22}, + [1076] = {.lex_state = 22}, + [1077] = {.lex_state = 8, .external_lex_state = 3}, + [1078] = {.lex_state = 8, .external_lex_state = 3}, + [1079] = {.lex_state = 22}, + [1080] = {.lex_state = 43}, + [1081] = {.lex_state = 43}, + [1082] = {.lex_state = 22}, + [1083] = {.lex_state = 8}, + [1084] = {.lex_state = 43}, + [1085] = {.lex_state = 43}, [1086] = {.lex_state = 8}, - [1087] = {.lex_state = 16}, - [1088] = {.lex_state = 41}, - [1089] = {.lex_state = 41}, - [1090] = {.lex_state = 16}, - [1091] = {.lex_state = 8}, - [1092] = {.lex_state = 8}, + [1087] = {.lex_state = 43, .external_lex_state = 3}, + [1088] = {.lex_state = 8}, + [1089] = {.lex_state = 43}, + [1090] = {.lex_state = 22}, + [1091] = {.lex_state = 22}, + [1092] = {.lex_state = 22}, [1093] = {.lex_state = 8}, - [1094] = {.lex_state = 8}, - [1095] = {.lex_state = 8, .external_lex_state = 3}, - [1096] = {.lex_state = 41}, - [1097] = {.lex_state = 41}, - [1098] = {.lex_state = 16}, - [1099] = {.lex_state = 41, .external_lex_state = 3}, - [1100] = {.lex_state = 41}, - [1101] = {.lex_state = 8}, - [1102] = {.lex_state = 8}, - [1103] = {.lex_state = 41}, - [1104] = {.lex_state = 41}, - [1105] = {.lex_state = 16}, - [1106] = {.lex_state = 41}, - [1107] = {.lex_state = 16}, - [1108] = {.lex_state = 8}, - [1109] = {.lex_state = 41}, - [1110] = {.lex_state = 41}, - [1111] = {.lex_state = 16}, - [1112] = {.lex_state = 41}, - [1113] = {.lex_state = 8, .external_lex_state = 3}, - [1114] = {.lex_state = 8}, - [1115] = {.lex_state = 41, .external_lex_state = 3}, - [1116] = {.lex_state = 8, .external_lex_state = 3}, - [1117] = {.lex_state = 16}, - [1118] = {.lex_state = 16}, - [1119] = {.lex_state = 16}, - [1120] = {.lex_state = 41}, - [1121] = {.lex_state = 41}, - [1122] = {.lex_state = 41}, - [1123] = {.lex_state = 41}, - [1124] = {.lex_state = 41}, - [1125] = {.lex_state = 41}, - [1126] = {.lex_state = 41}, - [1127] = {.lex_state = 41, .external_lex_state = 3}, - [1128] = {.lex_state = 8}, - [1129] = {.lex_state = 41}, - [1130] = {.lex_state = 41}, - [1131] = {.lex_state = 41}, - [1132] = {.lex_state = 41}, - [1133] = {.lex_state = 41}, - [1134] = {.lex_state = 41}, - [1135] = {.lex_state = 41}, - [1136] = {.lex_state = 41}, - [1137] = {.lex_state = 41}, - [1138] = {.lex_state = 41}, - [1139] = {.lex_state = 41, .external_lex_state = 3}, - [1140] = {.lex_state = 41}, - [1141] = {.lex_state = 41}, - [1142] = {.lex_state = 41, .external_lex_state = 3}, - [1143] = {.lex_state = 41}, - [1144] = {.lex_state = 41}, - [1145] = {.lex_state = 41}, - [1146] = {.lex_state = 41}, - [1147] = {.lex_state = 41}, - [1148] = {.lex_state = 41}, - [1149] = {.lex_state = 41}, - [1150] = {.lex_state = 8}, + [1094] = {.lex_state = 43}, + [1095] = {.lex_state = 22}, + [1096] = {.lex_state = 43}, + [1097] = {.lex_state = 43}, + [1098] = {.lex_state = 22}, + [1099] = {.lex_state = 43}, + [1100] = {.lex_state = 8}, + [1101] = {.lex_state = 43, .external_lex_state = 3}, + [1102] = {.lex_state = 43}, + [1103] = {.lex_state = 43}, + [1104] = {.lex_state = 22}, + [1105] = {.lex_state = 22}, + [1106] = {.lex_state = 8, .external_lex_state = 3}, + [1107] = {.lex_state = 22}, + [1108] = {.lex_state = 43}, + [1109] = {.lex_state = 43}, + [1110] = {.lex_state = 43, .external_lex_state = 3}, + [1111] = {.lex_state = 8}, + [1112] = {.lex_state = 22}, + [1113] = {.lex_state = 43}, + [1114] = {.lex_state = 22}, + [1115] = {.lex_state = 43}, + [1116] = {.lex_state = 43}, + [1117] = {.lex_state = 8}, + [1118] = {.lex_state = 43}, + [1119] = {.lex_state = 8}, + [1120] = {.lex_state = 43, .external_lex_state = 3}, + [1121] = {.lex_state = 43}, + [1122] = {.lex_state = 43}, + [1123] = {.lex_state = 43}, + [1124] = {.lex_state = 43}, + [1125] = {.lex_state = 43}, + [1126] = {.lex_state = 43}, + [1127] = {.lex_state = 43}, + [1128] = {.lex_state = 43}, + [1129] = {.lex_state = 43}, + [1130] = {.lex_state = 43}, + [1131] = {.lex_state = 43}, + [1132] = {.lex_state = 43}, + [1133] = {.lex_state = 43}, + [1134] = {.lex_state = 43}, + [1135] = {.lex_state = 43}, + [1136] = {.lex_state = 43}, + [1137] = {.lex_state = 43}, + [1138] = {.lex_state = 43}, + [1139] = {.lex_state = 8, .external_lex_state = 3}, + [1140] = {.lex_state = 9}, + [1141] = {.lex_state = 8, .external_lex_state = 3}, + [1142] = {.lex_state = 43}, + [1143] = {.lex_state = 43}, + [1144] = {.lex_state = 43}, + [1145] = {.lex_state = 43}, + [1146] = {.lex_state = 43}, + [1147] = {.lex_state = 43}, + [1148] = {.lex_state = 43}, + [1149] = {.lex_state = 43}, + [1150] = {.lex_state = 43}, [1151] = {.lex_state = 8}, - [1152] = {.lex_state = 41}, - [1153] = {.lex_state = 41}, - [1154] = {.lex_state = 41}, - [1155] = {.lex_state = 41}, - [1156] = {.lex_state = 41}, - [1157] = {.lex_state = 41}, - [1158] = {.lex_state = 41}, - [1159] = {.lex_state = 41}, - [1160] = {.lex_state = 41}, - [1161] = {.lex_state = 41}, - [1162] = {.lex_state = 41}, - [1163] = {.lex_state = 8}, - [1164] = {.lex_state = 41}, - [1165] = {.lex_state = 41}, - [1166] = {.lex_state = 41}, - [1167] = {.lex_state = 41}, - [1168] = {.lex_state = 41}, - [1169] = {.lex_state = 41}, - [1170] = {.lex_state = 8, .external_lex_state = 3}, - [1171] = {.lex_state = 41}, - [1172] = {.lex_state = 8, .external_lex_state = 3}, - [1173] = {.lex_state = 41}, - [1174] = {.lex_state = 41}, - [1175] = {.lex_state = 16}, - [1176] = {.lex_state = 41}, - [1177] = {.lex_state = 41}, - [1178] = {.lex_state = 41}, - [1179] = {.lex_state = 41}, - [1180] = {.lex_state = 41, .external_lex_state = 3}, - [1181] = {.lex_state = 8}, - [1182] = {.lex_state = 41}, - [1183] = {.lex_state = 41}, - [1184] = {.lex_state = 16}, - [1185] = {.lex_state = 41}, - [1186] = {.lex_state = 41}, - [1187] = {.lex_state = 41}, - [1188] = {.lex_state = 41}, - [1189] = {.lex_state = 41}, - [1190] = {.lex_state = 8}, - [1191] = {.lex_state = 8}, - [1192] = {.lex_state = 41}, - [1193] = {.lex_state = 41}, - [1194] = {.lex_state = 41}, - [1195] = {.lex_state = 41}, - [1196] = {.lex_state = 41}, - [1197] = {.lex_state = 41}, - [1198] = {.lex_state = 41}, - [1199] = {.lex_state = 41}, - [1200] = {.lex_state = 41}, - [1201] = {.lex_state = 41}, - [1202] = {.lex_state = 8, .external_lex_state = 3}, - [1203] = {.lex_state = 41}, - [1204] = {.lex_state = 41}, - [1205] = {.lex_state = 41}, - [1206] = {.lex_state = 41, .external_lex_state = 3}, - [1207] = {.lex_state = 41}, - [1208] = {.lex_state = 41}, - [1209] = {.lex_state = 41}, - [1210] = {.lex_state = 41}, - [1211] = {.lex_state = 41}, - [1212] = {.lex_state = 41, .external_lex_state = 3}, - [1213] = {.lex_state = 16}, - [1214] = {.lex_state = 41}, - [1215] = {.lex_state = 41}, - [1216] = {.lex_state = 41}, - [1217] = {.lex_state = 41}, - [1218] = {.lex_state = 41}, - [1219] = {.lex_state = 41}, - [1220] = {.lex_state = 41}, - [1221] = {.lex_state = 8}, - [1222] = {.lex_state = 41}, - [1223] = {.lex_state = 41}, - [1224] = {.lex_state = 41}, - [1225] = {.lex_state = 41}, - [1226] = {.lex_state = 41}, - [1227] = {.lex_state = 41}, - [1228] = {.lex_state = 41}, - [1229] = {.lex_state = 41}, - [1230] = {.lex_state = 41}, - [1231] = {.lex_state = 8}, - [1232] = {.lex_state = 41}, - [1233] = {.lex_state = 41}, - [1234] = {.lex_state = 41}, - [1235] = {.lex_state = 41}, - [1236] = {.lex_state = 41}, - [1237] = {.lex_state = 41}, - [1238] = {.lex_state = 41}, - [1239] = {.lex_state = 41}, - [1240] = {.lex_state = 41}, - [1241] = {.lex_state = 41}, - [1242] = {.lex_state = 41}, - [1243] = {.lex_state = 41}, - [1244] = {.lex_state = 41}, - [1245] = {.lex_state = 41}, - [1246] = {.lex_state = 41}, - [1247] = {.lex_state = 41}, - [1248] = {.lex_state = 41, .external_lex_state = 3}, - [1249] = {.lex_state = 41}, - [1250] = {.lex_state = 41, .external_lex_state = 3}, - [1251] = {.lex_state = 41}, - [1252] = {.lex_state = 41}, - [1253] = {.lex_state = 41}, - [1254] = {.lex_state = 41}, - [1255] = {.lex_state = 41}, - [1256] = {.lex_state = 41}, - [1257] = {.lex_state = 41}, - [1258] = {.lex_state = 8}, - [1259] = {.lex_state = 41}, - [1260] = {.lex_state = 41}, - [1261] = {.lex_state = 41}, - [1262] = {.lex_state = 41}, - [1263] = {.lex_state = 41}, - [1264] = {.lex_state = 41}, - [1265] = {.lex_state = 41}, - [1266] = {.lex_state = 8}, - [1267] = {.lex_state = 41}, - [1268] = {.lex_state = 16}, - [1269] = {.lex_state = 41}, - [1270] = {.lex_state = 41}, - [1271] = {.lex_state = 41}, - [1272] = {.lex_state = 16, .external_lex_state = 3}, - [1273] = {.lex_state = 41}, - [1274] = {.lex_state = 41, .external_lex_state = 3}, - [1275] = {.lex_state = 8}, - [1276] = {.lex_state = 41}, - [1277] = {.lex_state = 16, .external_lex_state = 3}, - [1278] = {.lex_state = 41}, - [1279] = {.lex_state = 41}, - [1280] = {.lex_state = 41}, - [1281] = {.lex_state = 41}, - [1282] = {.lex_state = 41}, - [1283] = {.lex_state = 41}, - [1284] = {.lex_state = 41}, - [1285] = {.lex_state = 41}, - [1286] = {.lex_state = 41}, - [1287] = {.lex_state = 41}, - [1288] = {.lex_state = 41}, - [1289] = {.lex_state = 41}, - [1290] = {.lex_state = 16}, - [1291] = {.lex_state = 41}, - [1292] = {.lex_state = 41}, - [1293] = {.lex_state = 41}, - [1294] = {.lex_state = 9}, - [1295] = {.lex_state = 16}, - [1296] = {.lex_state = 41}, - [1297] = {.lex_state = 41}, - [1298] = {.lex_state = 41}, - [1299] = {.lex_state = 41}, - [1300] = {.lex_state = 41}, - [1301] = {.lex_state = 41}, - [1302] = {.lex_state = 8}, - [1303] = {.lex_state = 8}, - [1304] = {.lex_state = 16, .external_lex_state = 3}, - [1305] = {.lex_state = 41}, - [1306] = {.lex_state = 41, .external_lex_state = 3}, - [1307] = {.lex_state = 41, .external_lex_state = 3}, - [1308] = {.lex_state = 41, .external_lex_state = 3}, - [1309] = {.lex_state = 41}, - [1310] = {.lex_state = 41}, - [1311] = {.lex_state = 41}, - [1312] = {.lex_state = 41}, - [1313] = {.lex_state = 8}, - [1314] = {.lex_state = 41, .external_lex_state = 3}, - [1315] = {.lex_state = 16}, - [1316] = {.lex_state = 9}, - [1317] = {.lex_state = 41}, - [1318] = {.lex_state = 41}, - [1319] = {.lex_state = 41, .external_lex_state = 3}, - [1320] = {.lex_state = 16}, - [1321] = {.lex_state = 41}, - [1322] = {.lex_state = 41}, - [1323] = {.lex_state = 16}, - [1324] = {.lex_state = 41}, - [1325] = {.lex_state = 8}, - [1326] = {.lex_state = 41}, - [1327] = {.lex_state = 8}, - [1328] = {.lex_state = 9}, - [1329] = {.lex_state = 41}, - [1330] = {.lex_state = 9}, - [1331] = {.lex_state = 8}, - [1332] = {.lex_state = 8}, - [1333] = {.lex_state = 41}, - [1334] = {.lex_state = 16, .external_lex_state = 3}, - [1335] = {.lex_state = 41}, - [1336] = {.lex_state = 8}, - [1337] = {.lex_state = 41, .external_lex_state = 3}, - [1338] = {.lex_state = 41}, - [1339] = {.lex_state = 8}, - [1340] = {.lex_state = 41, .external_lex_state = 3}, - [1341] = {.lex_state = 8}, - [1342] = {.lex_state = 41}, - [1343] = {.lex_state = 41}, - [1344] = {.lex_state = 8}, - [1345] = {.lex_state = 41}, - [1346] = {.lex_state = 8}, - [1347] = {.lex_state = 41}, - [1348] = {.lex_state = 8}, - [1349] = {.lex_state = 41}, - [1350] = {.lex_state = 41}, - [1351] = {.lex_state = 41}, - [1352] = {.lex_state = 41}, - [1353] = {.lex_state = 8}, - [1354] = {.lex_state = 41}, - [1355] = {.lex_state = 41}, - [1356] = {.lex_state = 41}, - [1357] = {.lex_state = 41}, - [1358] = {.lex_state = 8}, - [1359] = {.lex_state = 41}, - [1360] = {.lex_state = 41}, - [1361] = {.lex_state = 16}, + [1152] = {.lex_state = 43}, + [1153] = {.lex_state = 43}, + [1154] = {.lex_state = 43}, + [1155] = {.lex_state = 43}, + [1156] = {.lex_state = 43}, + [1157] = {.lex_state = 43}, + [1158] = {.lex_state = 8, .external_lex_state = 3}, + [1159] = {.lex_state = 43}, + [1160] = {.lex_state = 43}, + [1161] = {.lex_state = 43}, + [1162] = {.lex_state = 43}, + [1163] = {.lex_state = 43, .external_lex_state = 3}, + [1164] = {.lex_state = 43}, + [1165] = {.lex_state = 43}, + [1166] = {.lex_state = 22}, + [1167] = {.lex_state = 43}, + [1168] = {.lex_state = 43}, + [1169] = {.lex_state = 43}, + [1170] = {.lex_state = 43}, + [1171] = {.lex_state = 43}, + [1172] = {.lex_state = 43}, + [1173] = {.lex_state = 43, .external_lex_state = 3}, + [1174] = {.lex_state = 43}, + [1175] = {.lex_state = 43}, + [1176] = {.lex_state = 43}, + [1177] = {.lex_state = 43}, + [1178] = {.lex_state = 43}, + [1179] = {.lex_state = 43}, + [1180] = {.lex_state = 43}, + [1181] = {.lex_state = 43}, + [1182] = {.lex_state = 43}, + [1183] = {.lex_state = 43}, + [1184] = {.lex_state = 43}, + [1185] = {.lex_state = 43}, + [1186] = {.lex_state = 43}, + [1187] = {.lex_state = 22}, + [1188] = {.lex_state = 8}, + [1189] = {.lex_state = 43}, + [1190] = {.lex_state = 43}, + [1191] = {.lex_state = 43}, + [1192] = {.lex_state = 43}, + [1193] = {.lex_state = 43}, + [1194] = {.lex_state = 43}, + [1195] = {.lex_state = 43}, + [1196] = {.lex_state = 43}, + [1197] = {.lex_state = 8}, + [1198] = {.lex_state = 43}, + [1199] = {.lex_state = 43}, + [1200] = {.lex_state = 43}, + [1201] = {.lex_state = 43}, + [1202] = {.lex_state = 43}, + [1203] = {.lex_state = 8}, + [1204] = {.lex_state = 43}, + [1205] = {.lex_state = 43}, + [1206] = {.lex_state = 43}, + [1207] = {.lex_state = 43}, + [1208] = {.lex_state = 43}, + [1209] = {.lex_state = 43}, + [1210] = {.lex_state = 43}, + [1211] = {.lex_state = 8}, + [1212] = {.lex_state = 43}, + [1213] = {.lex_state = 43}, + [1214] = {.lex_state = 43}, + [1215] = {.lex_state = 43, .external_lex_state = 3}, + [1216] = {.lex_state = 43}, + [1217] = {.lex_state = 43}, + [1218] = {.lex_state = 43}, + [1219] = {.lex_state = 43}, + [1220] = {.lex_state = 43}, + [1221] = {.lex_state = 43}, + [1222] = {.lex_state = 43}, + [1223] = {.lex_state = 43}, + [1224] = {.lex_state = 43}, + [1225] = {.lex_state = 43}, + [1226] = {.lex_state = 43}, + [1227] = {.lex_state = 8}, + [1228] = {.lex_state = 43}, + [1229] = {.lex_state = 43, .external_lex_state = 3}, + [1230] = {.lex_state = 43}, + [1231] = {.lex_state = 43}, + [1232] = {.lex_state = 43}, + [1233] = {.lex_state = 8}, + [1234] = {.lex_state = 43, .external_lex_state = 3}, + [1235] = {.lex_state = 43}, + [1236] = {.lex_state = 43}, + [1237] = {.lex_state = 43}, + [1238] = {.lex_state = 9}, + [1239] = {.lex_state = 43}, + [1240] = {.lex_state = 43, .external_lex_state = 3}, + [1241] = {.lex_state = 43}, + [1242] = {.lex_state = 43}, + [1243] = {.lex_state = 43}, + [1244] = {.lex_state = 43}, + [1245] = {.lex_state = 8}, + [1246] = {.lex_state = 43}, + [1247] = {.lex_state = 43}, + [1248] = {.lex_state = 43, .external_lex_state = 3}, + [1249] = {.lex_state = 43}, + [1250] = {.lex_state = 43}, + [1251] = {.lex_state = 43}, + [1252] = {.lex_state = 43}, + [1253] = {.lex_state = 43}, + [1254] = {.lex_state = 43}, + [1255] = {.lex_state = 43}, + [1256] = {.lex_state = 43}, + [1257] = {.lex_state = 43}, + [1258] = {.lex_state = 43}, + [1259] = {.lex_state = 8}, + [1260] = {.lex_state = 43}, + [1261] = {.lex_state = 43}, + [1262] = {.lex_state = 43}, + [1263] = {.lex_state = 43}, + [1264] = {.lex_state = 43}, + [1265] = {.lex_state = 43}, + [1266] = {.lex_state = 43}, + [1267] = {.lex_state = 43}, + [1268] = {.lex_state = 43}, + [1269] = {.lex_state = 9, .external_lex_state = 3}, + [1270] = {.lex_state = 43}, + [1271] = {.lex_state = 43}, + [1272] = {.lex_state = 8}, + [1273] = {.lex_state = 43, .external_lex_state = 3}, + [1274] = {.lex_state = 43}, + [1275] = {.lex_state = 9, .external_lex_state = 3}, + [1276] = {.lex_state = 43}, + [1277] = {.lex_state = 43}, + [1278] = {.lex_state = 43}, + [1279] = {.lex_state = 43}, + [1280] = {.lex_state = 43}, + [1281] = {.lex_state = 43}, + [1282] = {.lex_state = 43}, + [1283] = {.lex_state = 43}, + [1284] = {.lex_state = 43}, + [1285] = {.lex_state = 43}, + [1286] = {.lex_state = 43}, + [1287] = {.lex_state = 22}, + [1288] = {.lex_state = 43}, + [1289] = {.lex_state = 43}, + [1290] = {.lex_state = 43}, + [1291] = {.lex_state = 43}, + [1292] = {.lex_state = 43}, + [1293] = {.lex_state = 22}, + [1294] = {.lex_state = 43}, + [1295] = {.lex_state = 43}, + [1296] = {.lex_state = 43}, + [1297] = {.lex_state = 43}, + [1298] = {.lex_state = 8}, + [1299] = {.lex_state = 43}, + [1300] = {.lex_state = 43}, + [1301] = {.lex_state = 43}, + [1302] = {.lex_state = 9, .external_lex_state = 3}, + [1303] = {.lex_state = 43, .external_lex_state = 3}, + [1304] = {.lex_state = 43, .external_lex_state = 3}, + [1305] = {.lex_state = 43, .external_lex_state = 3}, + [1306] = {.lex_state = 43}, + [1307] = {.lex_state = 43}, + [1308] = {.lex_state = 43}, + [1309] = {.lex_state = 43}, + [1310] = {.lex_state = 43}, + [1311] = {.lex_state = 43}, + [1312] = {.lex_state = 43}, + [1313] = {.lex_state = 43, .external_lex_state = 3}, + [1314] = {.lex_state = 22}, + [1315] = {.lex_state = 43}, + [1316] = {.lex_state = 43}, + [1317] = {.lex_state = 43}, + [1318] = {.lex_state = 43, .external_lex_state = 3}, + [1319] = {.lex_state = 43}, + [1320] = {.lex_state = 22}, + [1321] = {.lex_state = 43}, + [1322] = {.lex_state = 43}, + [1323] = {.lex_state = 8}, + [1324] = {.lex_state = 43}, + [1325] = {.lex_state = 43}, + [1326] = {.lex_state = 43}, + [1327] = {.lex_state = 43}, + [1328] = {.lex_state = 43}, + [1329] = {.lex_state = 43}, + [1330] = {.lex_state = 43}, + [1331] = {.lex_state = 43}, + [1332] = {.lex_state = 43}, + [1333] = {.lex_state = 9, .external_lex_state = 3}, + [1334] = {.lex_state = 43}, + [1335] = {.lex_state = 43}, + [1336] = {.lex_state = 43, .external_lex_state = 3}, + [1337] = {.lex_state = 43}, + [1338] = {.lex_state = 43}, + [1339] = {.lex_state = 43, .external_lex_state = 3}, + [1340] = {.lex_state = 43}, + [1341] = {.lex_state = 43}, + [1342] = {.lex_state = 43}, + [1343] = {.lex_state = 43}, + [1344] = {.lex_state = 43}, + [1345] = {.lex_state = 43}, + [1346] = {.lex_state = 43}, + [1347] = {.lex_state = 43}, + [1348] = {.lex_state = 43}, + [1349] = {.lex_state = 43}, + [1350] = {.lex_state = 43}, + [1351] = {.lex_state = 43}, + [1352] = {.lex_state = 43}, + [1353] = {.lex_state = 43}, + [1354] = {.lex_state = 43}, + [1355] = {.lex_state = 43}, + [1356] = {.lex_state = 43}, + [1357] = {.lex_state = 43}, + [1358] = {.lex_state = 22}, + [1359] = {.lex_state = 43}, + [1360] = {.lex_state = 8}, + [1361] = {.lex_state = 43}, [1362] = {.lex_state = 8}, - [1363] = {.lex_state = 8}, - [1364] = {.lex_state = 41}, - [1365] = {.lex_state = 41}, - [1366] = {.lex_state = 41}, - [1367] = {.lex_state = 41}, - [1368] = {.lex_state = 41}, - [1369] = {.lex_state = 41}, - [1370] = {.lex_state = 41}, - [1371] = {.lex_state = 41}, - [1372] = {.lex_state = 41}, - [1373] = {.lex_state = 41}, - [1374] = {.lex_state = 41, .external_lex_state = 3}, - [1375] = {.lex_state = 41}, - [1376] = {.lex_state = 41}, - [1377] = {.lex_state = 41, .external_lex_state = 3}, - [1378] = {.lex_state = 41}, - [1379] = {.lex_state = 41, .external_lex_state = 3}, - [1380] = {.lex_state = 41}, - [1381] = {.lex_state = 41}, - [1382] = {.lex_state = 41}, - [1383] = {.lex_state = 41, .external_lex_state = 3}, - [1384] = {.lex_state = 41}, - [1385] = {.lex_state = 41}, - [1386] = {.lex_state = 8}, - [1387] = {.lex_state = 41, .external_lex_state = 3}, - [1388] = {.lex_state = 41}, - [1389] = {.lex_state = 16}, - [1390] = {.lex_state = 41}, - [1391] = {.lex_state = 41}, - [1392] = {.lex_state = 41}, - [1393] = {.lex_state = 16}, - [1394] = {.lex_state = 8}, - [1395] = {.lex_state = 8}, - [1396] = {.lex_state = 16}, - [1397] = {.lex_state = 41, .external_lex_state = 3}, - [1398] = {.lex_state = 41}, - [1399] = {.lex_state = 8}, - [1400] = {.lex_state = 41}, - [1401] = {.lex_state = 41}, - [1402] = {.lex_state = 41}, - [1403] = {.lex_state = 41}, - [1404] = {.lex_state = 41}, - [1405] = {.lex_state = 41}, - [1406] = {.lex_state = 41, .external_lex_state = 3}, - [1407] = {.lex_state = 41, .external_lex_state = 3}, - [1408] = {.lex_state = 41}, - [1409] = {.lex_state = 41, .external_lex_state = 3}, - [1410] = {.lex_state = 41, .external_lex_state = 3}, - [1411] = {.lex_state = 41, .external_lex_state = 3}, - [1412] = {.lex_state = 41}, - [1413] = {.lex_state = 41}, - [1414] = {.lex_state = 16}, + [1363] = {.lex_state = 22}, + [1364] = {.lex_state = 43}, + [1365] = {.lex_state = 43, .external_lex_state = 3}, + [1366] = {.lex_state = 43}, + [1367] = {.lex_state = 43}, + [1368] = {.lex_state = 43}, + [1369] = {.lex_state = 43}, + [1370] = {.lex_state = 10}, + [1371] = {.lex_state = 43}, + [1372] = {.lex_state = 43}, + [1373] = {.lex_state = 43}, + [1374] = {.lex_state = 22}, + [1375] = {.lex_state = 43, .external_lex_state = 3}, + [1376] = {.lex_state = 43}, + [1377] = {.lex_state = 43}, + [1378] = {.lex_state = 43}, + [1379] = {.lex_state = 43}, + [1380] = {.lex_state = 43, .external_lex_state = 3}, + [1381] = {.lex_state = 43}, + [1382] = {.lex_state = 43}, + [1383] = {.lex_state = 43, .external_lex_state = 3}, + [1384] = {.lex_state = 9}, + [1385] = {.lex_state = 43}, + [1386] = {.lex_state = 43}, + [1387] = {.lex_state = 43}, + [1388] = {.lex_state = 43}, + [1389] = {.lex_state = 43, .external_lex_state = 3}, + [1390] = {.lex_state = 43}, + [1391] = {.lex_state = 22}, + [1392] = {.lex_state = 22}, + [1393] = {.lex_state = 8}, + [1394] = {.lex_state = 43}, + [1395] = {.lex_state = 43}, + [1396] = {.lex_state = 43}, + [1397] = {.lex_state = 43}, + [1398] = {.lex_state = 43}, + [1399] = {.lex_state = 43}, + [1400] = {.lex_state = 43}, + [1401] = {.lex_state = 8}, + [1402] = {.lex_state = 43, .external_lex_state = 3}, + [1403] = {.lex_state = 43}, + [1404] = {.lex_state = 43, .external_lex_state = 3}, + [1405] = {.lex_state = 43, .external_lex_state = 3}, + [1406] = {.lex_state = 43}, + [1407] = {.lex_state = 43}, + [1408] = {.lex_state = 43}, + [1409] = {.lex_state = 9}, + [1410] = {.lex_state = 8}, + [1411] = {.lex_state = 43}, + [1412] = {.lex_state = 43}, + [1413] = {.lex_state = 43}, + [1414] = {.lex_state = 43, .external_lex_state = 3}, [1415] = {.lex_state = 8}, - [1416] = {.lex_state = 41}, - [1417] = {.lex_state = 41}, - [1418] = {.lex_state = 41}, - [1419] = {.lex_state = 41, .external_lex_state = 3}, - [1420] = {.lex_state = 41, .external_lex_state = 3}, - [1421] = {.lex_state = 41, .external_lex_state = 3}, - [1422] = {.lex_state = 16}, - [1423] = {.lex_state = 41, .external_lex_state = 3}, - [1424] = {.lex_state = 41}, - [1425] = {.lex_state = 41}, - [1426] = {.lex_state = 16}, - [1427] = {.lex_state = 41, .external_lex_state = 3}, - [1428] = {.lex_state = 41, .external_lex_state = 3}, - [1429] = {.lex_state = 41, .external_lex_state = 3}, - [1430] = {.lex_state = 41}, - [1431] = {.lex_state = 41}, - [1432] = {.lex_state = 41}, - [1433] = {.lex_state = 41, .external_lex_state = 3}, - [1434] = {.lex_state = 41, .external_lex_state = 3}, - [1435] = {.lex_state = 41}, - [1436] = {.lex_state = 41, .external_lex_state = 3}, - [1437] = {.lex_state = 41}, - [1438] = {.lex_state = 16}, - [1439] = {.lex_state = 16}, - [1440] = {.lex_state = 41}, - [1441] = {.lex_state = 41}, - [1442] = {.lex_state = 41}, - [1443] = {.lex_state = 41}, - [1444] = {.lex_state = 41, .external_lex_state = 3}, - [1445] = {.lex_state = 8}, - [1446] = {.lex_state = 41}, - [1447] = {.lex_state = 41}, - [1448] = {.lex_state = 41, .external_lex_state = 3}, - [1449] = {.lex_state = 41, .external_lex_state = 3}, - [1450] = {.lex_state = 41}, - [1451] = {.lex_state = 41}, - [1452] = {.lex_state = 41}, - [1453] = {.lex_state = 41}, - [1454] = {.lex_state = 41, .external_lex_state = 3}, - [1455] = {.lex_state = 41}, - [1456] = {.lex_state = 41, .external_lex_state = 3}, - [1457] = {.lex_state = 41, .external_lex_state = 3}, - [1458] = {.lex_state = 41, .external_lex_state = 3}, - [1459] = {.lex_state = 41}, - [1460] = {.lex_state = 41, .external_lex_state = 3}, - [1461] = {.lex_state = 41, .external_lex_state = 3}, - [1462] = {.lex_state = 41}, - [1463] = {.lex_state = 8}, - [1464] = {.lex_state = 41}, - [1465] = {.lex_state = 41}, - [1466] = {.lex_state = 41}, - [1467] = {.lex_state = 41}, - [1468] = {.lex_state = 41, .external_lex_state = 3}, - [1469] = {.lex_state = 41}, - [1470] = {.lex_state = 16}, - [1471] = {.lex_state = 41}, - [1472] = {.lex_state = 41, .external_lex_state = 3}, - [1473] = {.lex_state = 41}, - [1474] = {.lex_state = 41}, - [1475] = {.lex_state = 41}, - [1476] = {.lex_state = 41}, - [1477] = {.lex_state = 41}, - [1478] = {.lex_state = 8}, - [1479] = {.lex_state = 41, .external_lex_state = 3}, - [1480] = {.lex_state = 41}, - [1481] = {.lex_state = 41}, - [1482] = {.lex_state = 41}, + [1416] = {.lex_state = 43}, + [1417] = {.lex_state = 8}, + [1418] = {.lex_state = 43, .external_lex_state = 3}, + [1419] = {.lex_state = 43, .external_lex_state = 3}, + [1420] = {.lex_state = 43}, + [1421] = {.lex_state = 22}, + [1422] = {.lex_state = 43}, + [1423] = {.lex_state = 43, .external_lex_state = 3}, + [1424] = {.lex_state = 43, .external_lex_state = 3}, + [1425] = {.lex_state = 43, .external_lex_state = 3}, + [1426] = {.lex_state = 43}, + [1427] = {.lex_state = 43}, + [1428] = {.lex_state = 43}, + [1429] = {.lex_state = 43, .external_lex_state = 3}, + [1430] = {.lex_state = 43}, + [1431] = {.lex_state = 43}, + [1432] = {.lex_state = 9}, + [1433] = {.lex_state = 9}, + [1434] = {.lex_state = 43, .external_lex_state = 3}, + [1435] = {.lex_state = 43}, + [1436] = {.lex_state = 43, .external_lex_state = 3}, + [1437] = {.lex_state = 43}, + [1438] = {.lex_state = 43}, + [1439] = {.lex_state = 43, .external_lex_state = 3}, + [1440] = {.lex_state = 43, .external_lex_state = 3}, + [1441] = {.lex_state = 43}, + [1442] = {.lex_state = 43, .external_lex_state = 3}, + [1443] = {.lex_state = 43, .external_lex_state = 3}, + [1444] = {.lex_state = 8}, + [1445] = {.lex_state = 43}, + [1446] = {.lex_state = 43}, + [1447] = {.lex_state = 43}, + [1448] = {.lex_state = 43, .external_lex_state = 3}, + [1449] = {.lex_state = 43}, + [1450] = {.lex_state = 43}, + [1451] = {.lex_state = 43, .external_lex_state = 3}, + [1452] = {.lex_state = 43}, + [1453] = {.lex_state = 43, .external_lex_state = 3}, + [1454] = {.lex_state = 43}, + [1455] = {.lex_state = 43}, + [1456] = {.lex_state = 43}, + [1457] = {.lex_state = 8}, + [1458] = {.lex_state = 43}, + [1459] = {.lex_state = 43, .external_lex_state = 3}, + [1460] = {.lex_state = 43}, + [1461] = {.lex_state = 43, .external_lex_state = 3}, + [1462] = {.lex_state = 43}, + [1463] = {.lex_state = 43, .external_lex_state = 3}, + [1464] = {.lex_state = 43, .external_lex_state = 3}, + [1465] = {.lex_state = 43}, + [1466] = {.lex_state = 10}, + [1467] = {.lex_state = 43}, + [1468] = {.lex_state = 43, .external_lex_state = 3}, + [1469] = {.lex_state = 43}, + [1470] = {.lex_state = 43, .external_lex_state = 3}, + [1471] = {.lex_state = 43}, + [1472] = {.lex_state = 43}, + [1473] = {.lex_state = 43}, + [1474] = {.lex_state = 43, .external_lex_state = 3}, + [1475] = {.lex_state = 43, .external_lex_state = 3}, + [1476] = {.lex_state = 8}, + [1477] = {.lex_state = 43}, + [1478] = {.lex_state = 43}, + [1479] = {.lex_state = 43}, + [1480] = {.lex_state = 43}, + [1481] = {.lex_state = 43}, + [1482] = {.lex_state = 43}, [1483] = {.lex_state = 8}, - [1484] = {.lex_state = 8}, - [1485] = {.lex_state = 41}, - [1486] = {.lex_state = 41, .external_lex_state = 3}, - [1487] = {.lex_state = 41}, - [1488] = {.lex_state = 41, .external_lex_state = 3}, - [1489] = {.lex_state = 41}, - [1490] = {.lex_state = 41, .external_lex_state = 3}, - [1491] = {.lex_state = 8}, - [1492] = {.lex_state = 41}, - [1493] = {.lex_state = 41}, - [1494] = {.lex_state = 41}, - [1495] = {.lex_state = 41, .external_lex_state = 3}, - [1496] = {.lex_state = 16}, - [1497] = {.lex_state = 41, .external_lex_state = 3}, - [1498] = {.lex_state = 41, .external_lex_state = 3}, - [1499] = {.lex_state = 41}, - [1500] = {.lex_state = 41}, - [1501] = {.lex_state = 41}, - [1502] = {.lex_state = 41}, - [1503] = {.lex_state = 41, .external_lex_state = 3}, - [1504] = {.lex_state = 41}, - [1505] = {.lex_state = 41, .external_lex_state = 3}, - [1506] = {.lex_state = 16}, - [1507] = {.lex_state = 41, .external_lex_state = 3}, - [1508] = {.lex_state = 41}, - [1509] = {.lex_state = 41, .external_lex_state = 3}, - [1510] = {.lex_state = 41}, - [1511] = {.lex_state = 41, .external_lex_state = 3}, - [1512] = {.lex_state = 41}, - [1513] = {.lex_state = 41, .external_lex_state = 3}, - [1514] = {.lex_state = 41}, - [1515] = {.lex_state = 8}, - [1516] = {.lex_state = 41}, - [1517] = {.lex_state = 41}, - [1518] = {.lex_state = 41, .external_lex_state = 3}, - [1519] = {.lex_state = 41}, - [1520] = {.lex_state = 41}, - [1521] = {.lex_state = 16}, - [1522] = {.lex_state = 41, .external_lex_state = 3}, - [1523] = {.lex_state = 41}, - [1524] = {.lex_state = 16}, - [1525] = {.lex_state = 41}, - [1526] = {.lex_state = 41}, - [1527] = {.lex_state = 41}, - [1528] = {.lex_state = 16}, - [1529] = {.lex_state = 16}, - [1530] = {.lex_state = 41, .external_lex_state = 3}, - [1531] = {.lex_state = 41, .external_lex_state = 3}, - [1532] = {.lex_state = 16}, - [1533] = {.lex_state = 8}, - [1534] = {.lex_state = 41}, - [1535] = {.lex_state = 16}, - [1536] = {.lex_state = 16}, - [1537] = {.lex_state = 41}, - [1538] = {.lex_state = 41, .external_lex_state = 3}, - [1539] = {.lex_state = 16}, - [1540] = {.lex_state = 41, .external_lex_state = 3}, - [1541] = {.lex_state = 41}, - [1542] = {.lex_state = 41}, - [1543] = {.lex_state = 41}, - [1544] = {.lex_state = 41}, - [1545] = {.lex_state = 41}, - [1546] = {.lex_state = 41}, - [1547] = {.lex_state = 41}, - [1548] = {.lex_state = 41}, - [1549] = {.lex_state = 41}, - [1550] = {.lex_state = 41}, - [1551] = {.lex_state = 41}, - [1552] = {.lex_state = 41}, - [1553] = {.lex_state = 41}, - [1554] = {.lex_state = 41}, - [1555] = {.lex_state = 41}, - [1556] = {.lex_state = 41}, - [1557] = {.lex_state = 41, .external_lex_state = 3}, - [1558] = {.lex_state = 41}, - [1559] = {.lex_state = 41, .external_lex_state = 3}, - [1560] = {.lex_state = 8}, - [1561] = {.lex_state = 41}, - [1562] = {.lex_state = 41}, - [1563] = {.lex_state = 41}, - [1564] = {.lex_state = 8}, - [1565] = {.lex_state = 41, .external_lex_state = 3}, - [1566] = {.lex_state = 41, .external_lex_state = 3}, - [1567] = {.lex_state = 41}, - [1568] = {.lex_state = 41}, - [1569] = {.lex_state = 41}, - [1570] = {.lex_state = 41}, - [1571] = {.lex_state = 41, .external_lex_state = 3}, - [1572] = {.lex_state = 41}, - [1573] = {.lex_state = 41}, - [1574] = {.lex_state = 9}, - [1575] = {.lex_state = 41}, - [1576] = {.lex_state = 41}, - [1577] = {.lex_state = 41}, - [1578] = {.lex_state = 41, .external_lex_state = 3}, - [1579] = {.lex_state = 41}, - [1580] = {.lex_state = 41}, - [1581] = {.lex_state = 41}, - [1582] = {.lex_state = 41}, - [1583] = {.lex_state = 41, .external_lex_state = 3}, - [1584] = {.lex_state = 41, .external_lex_state = 3}, - [1585] = {.lex_state = 41, .external_lex_state = 3}, - [1586] = {.lex_state = 41}, - [1587] = {.lex_state = 41}, - [1588] = {.lex_state = 41, .external_lex_state = 3}, - [1589] = {.lex_state = 41}, - [1590] = {.lex_state = 41}, - [1591] = {.lex_state = 8}, - [1592] = {.lex_state = 41}, - [1593] = {.lex_state = 41, .external_lex_state = 3}, - [1594] = {.lex_state = 41}, - [1595] = {.lex_state = 41}, - [1596] = {.lex_state = 8}, - [1597] = {.lex_state = 41}, - [1598] = {.lex_state = 41}, - [1599] = {.lex_state = 41}, - [1600] = {.lex_state = 41}, - [1601] = {.lex_state = 41, .external_lex_state = 3}, - [1602] = {.lex_state = 41}, - [1603] = {.lex_state = 41, .external_lex_state = 3}, - [1604] = {.lex_state = 41}, - [1605] = {.lex_state = 41}, - [1606] = {.lex_state = 41}, - [1607] = {.lex_state = 41}, - [1608] = {.lex_state = 41}, - [1609] = {.lex_state = 41, .external_lex_state = 3}, - [1610] = {.lex_state = 41}, - [1611] = {.lex_state = 41, .external_lex_state = 3}, - [1612] = {.lex_state = 16}, - [1613] = {.lex_state = 41, .external_lex_state = 3}, - [1614] = {.lex_state = 41}, - [1615] = {.lex_state = 41}, - [1616] = {.lex_state = 41}, - [1617] = {.lex_state = 41}, - [1618] = {.lex_state = 41}, - [1619] = {.lex_state = 8}, - [1620] = {.lex_state = 41}, - [1621] = {.lex_state = 8}, - [1622] = {.lex_state = 41}, - [1623] = {.lex_state = 9}, - [1624] = {.lex_state = 41, .external_lex_state = 3}, - [1625] = {.lex_state = 41}, - [1626] = {.lex_state = 41}, - [1627] = {.lex_state = 41}, - [1628] = {.lex_state = 41}, - [1629] = {.lex_state = 41}, - [1630] = {.lex_state = 16}, - [1631] = {.lex_state = 41, .external_lex_state = 3}, - [1632] = {.lex_state = 41}, - [1633] = {.lex_state = 41}, - [1634] = {.lex_state = 41}, - [1635] = {.lex_state = 41}, - [1636] = {.lex_state = 41, .external_lex_state = 3}, - [1637] = {.lex_state = 41, .external_lex_state = 3}, - [1638] = {.lex_state = 41, .external_lex_state = 3}, - [1639] = {.lex_state = 41, .external_lex_state = 3}, - [1640] = {.lex_state = 41}, - [1641] = {.lex_state = 41, .external_lex_state = 3}, - [1642] = {.lex_state = 41}, - [1643] = {.lex_state = 41}, - [1644] = {.lex_state = 8}, - [1645] = {.lex_state = 41}, - [1646] = {.lex_state = 41, .external_lex_state = 3}, - [1647] = {.lex_state = 41}, - [1648] = {.lex_state = 41}, - [1649] = {.lex_state = 41}, - [1650] = {.lex_state = 41}, - [1651] = {.lex_state = 41, .external_lex_state = 3}, - [1652] = {.lex_state = 41}, - [1653] = {.lex_state = 41}, - [1654] = {.lex_state = 9}, - [1655] = {.lex_state = 41}, - [1656] = {.lex_state = 41}, - [1657] = {.lex_state = 41}, - [1658] = {.lex_state = 41, .external_lex_state = 3}, - [1659] = {.lex_state = 41}, - [1660] = {.lex_state = 41, .external_lex_state = 3}, - [1661] = {.lex_state = 41, .external_lex_state = 3}, - [1662] = {.lex_state = 41}, - [1663] = {.lex_state = 41, .external_lex_state = 3}, - [1664] = {.lex_state = 41}, - [1665] = {.lex_state = 41}, - [1666] = {.lex_state = 16}, - [1667] = {.lex_state = 41}, - [1668] = {.lex_state = 41}, - [1669] = {.lex_state = 41}, - [1670] = {.lex_state = 41, .external_lex_state = 3}, - [1671] = {.lex_state = 41}, - [1672] = {.lex_state = 41}, - [1673] = {.lex_state = 41}, - [1674] = {.lex_state = 41, .external_lex_state = 3}, - [1675] = {.lex_state = 41}, - [1676] = {.lex_state = 41}, - [1677] = {.lex_state = 41}, - [1678] = {.lex_state = 41}, - [1679] = {.lex_state = 41}, - [1680] = {.lex_state = 41}, - [1681] = {.lex_state = 41}, - [1682] = {.lex_state = 41}, - [1683] = {.lex_state = 41}, - [1684] = {.lex_state = 41}, - [1685] = {.lex_state = 41}, - [1686] = {.lex_state = 41}, - [1687] = {.lex_state = 41}, - [1688] = {.lex_state = 41}, - [1689] = {.lex_state = 16}, - [1690] = {.lex_state = 41}, - [1691] = {.lex_state = 41}, - [1692] = {.lex_state = 16}, - [1693] = {.lex_state = 41}, - [1694] = {.lex_state = 41, .external_lex_state = 3}, - [1695] = {.lex_state = 41}, - [1696] = {.lex_state = 41}, - [1697] = {.lex_state = 41}, - [1698] = {.lex_state = 41}, - [1699] = {.lex_state = 41}, - [1700] = {.lex_state = 41}, - [1701] = {.lex_state = 41}, + [1484] = {.lex_state = 43}, + [1485] = {.lex_state = 43}, + [1486] = {.lex_state = 8}, + [1487] = {.lex_state = 43}, + [1488] = {.lex_state = 43, .external_lex_state = 3}, + [1489] = {.lex_state = 43, .external_lex_state = 3}, + [1490] = {.lex_state = 8}, + [1491] = {.lex_state = 22}, + [1492] = {.lex_state = 43}, + [1493] = {.lex_state = 43}, + [1494] = {.lex_state = 43}, + [1495] = {.lex_state = 43}, + [1496] = {.lex_state = 43}, + [1497] = {.lex_state = 43, .external_lex_state = 3}, + [1498] = {.lex_state = 43, .external_lex_state = 3}, + [1499] = {.lex_state = 43}, + [1500] = {.lex_state = 43}, + [1501] = {.lex_state = 22}, + [1502] = {.lex_state = 43}, + [1503] = {.lex_state = 43, .external_lex_state = 3}, + [1504] = {.lex_state = 43, .external_lex_state = 3}, + [1505] = {.lex_state = 43, .external_lex_state = 3}, + [1506] = {.lex_state = 43}, + [1507] = {.lex_state = 43}, + [1508] = {.lex_state = 43, .external_lex_state = 3}, + [1509] = {.lex_state = 43}, + [1510] = {.lex_state = 43, .external_lex_state = 3}, + [1511] = {.lex_state = 43, .external_lex_state = 3}, + [1512] = {.lex_state = 43}, + [1513] = {.lex_state = 43, .external_lex_state = 3}, + [1514] = {.lex_state = 43}, + [1515] = {.lex_state = 43}, + [1516] = {.lex_state = 43}, + [1517] = {.lex_state = 43}, + [1518] = {.lex_state = 43}, + [1519] = {.lex_state = 9}, + [1520] = {.lex_state = 43}, + [1521] = {.lex_state = 43}, + [1522] = {.lex_state = 43}, + [1523] = {.lex_state = 22}, + [1524] = {.lex_state = 43, .external_lex_state = 3}, + [1525] = {.lex_state = 22}, + [1526] = {.lex_state = 43, .external_lex_state = 3}, + [1527] = {.lex_state = 9}, + [1528] = {.lex_state = 8}, + [1529] = {.lex_state = 43}, + [1530] = {.lex_state = 22}, + [1531] = {.lex_state = 43}, + [1532] = {.lex_state = 43}, + [1533] = {.lex_state = 43, .external_lex_state = 3}, + [1534] = {.lex_state = 9}, + [1535] = {.lex_state = 43}, + [1536] = {.lex_state = 43}, + [1537] = {.lex_state = 22}, + [1538] = {.lex_state = 43}, + [1539] = {.lex_state = 43}, + [1540] = {.lex_state = 43, .external_lex_state = 3}, + [1541] = {.lex_state = 9}, + [1542] = {.lex_state = 43}, + [1543] = {.lex_state = 43, .external_lex_state = 3}, + [1544] = {.lex_state = 43}, + [1545] = {.lex_state = 43}, + [1546] = {.lex_state = 43}, + [1547] = {.lex_state = 43, .external_lex_state = 3}, + [1548] = {.lex_state = 43, .external_lex_state = 3}, + [1549] = {.lex_state = 43}, + [1550] = {.lex_state = 43, .external_lex_state = 3}, + [1551] = {.lex_state = 43}, + [1552] = {.lex_state = 43, .external_lex_state = 3}, + [1553] = {.lex_state = 8}, + [1554] = {.lex_state = 43}, + [1555] = {.lex_state = 43}, + [1556] = {.lex_state = 9}, + [1557] = {.lex_state = 43}, + [1558] = {.lex_state = 43}, + [1559] = {.lex_state = 43, .external_lex_state = 3}, + [1560] = {.lex_state = 43}, + [1561] = {.lex_state = 43}, + [1562] = {.lex_state = 43}, + [1563] = {.lex_state = 43, .external_lex_state = 3}, + [1564] = {.lex_state = 43, .external_lex_state = 3}, + [1565] = {.lex_state = 43}, + [1566] = {.lex_state = 43}, + [1567] = {.lex_state = 10}, + [1568] = {.lex_state = 43}, + [1569] = {.lex_state = 43}, + [1570] = {.lex_state = 43}, + [1571] = {.lex_state = 43}, + [1572] = {.lex_state = 43}, + [1573] = {.lex_state = 43, .external_lex_state = 3}, + [1574] = {.lex_state = 43}, + [1575] = {.lex_state = 43}, + [1576] = {.lex_state = 43, .external_lex_state = 3}, + [1577] = {.lex_state = 43}, + [1578] = {.lex_state = 43}, + [1579] = {.lex_state = 43, .external_lex_state = 3}, + [1580] = {.lex_state = 8}, + [1581] = {.lex_state = 43}, + [1582] = {.lex_state = 43}, + [1583] = {.lex_state = 43}, + [1584] = {.lex_state = 43, .external_lex_state = 3}, + [1585] = {.lex_state = 43}, + [1586] = {.lex_state = 22}, + [1587] = {.lex_state = 43}, + [1588] = {.lex_state = 43, .external_lex_state = 3}, + [1589] = {.lex_state = 8}, + [1590] = {.lex_state = 43, .external_lex_state = 3}, + [1591] = {.lex_state = 43, .external_lex_state = 3}, + [1592] = {.lex_state = 43}, + [1593] = {.lex_state = 43}, + [1594] = {.lex_state = 43}, + [1595] = {.lex_state = 43}, + [1596] = {.lex_state = 43, .external_lex_state = 3}, + [1597] = {.lex_state = 43}, + [1598] = {.lex_state = 43}, + [1599] = {.lex_state = 43, .external_lex_state = 3}, + [1600] = {.lex_state = 43}, + [1601] = {.lex_state = 43}, + [1602] = {.lex_state = 43, .external_lex_state = 3}, + [1603] = {.lex_state = 43}, + [1604] = {.lex_state = 8}, + [1605] = {.lex_state = 43}, + [1606] = {.lex_state = 22}, + [1607] = {.lex_state = 43, .external_lex_state = 3}, + [1608] = {.lex_state = 43}, + [1609] = {.lex_state = 43}, + [1610] = {.lex_state = 43}, + [1611] = {.lex_state = 43}, + [1612] = {.lex_state = 43}, + [1613] = {.lex_state = 43}, + [1614] = {.lex_state = 8}, + [1615] = {.lex_state = 43}, + [1616] = {.lex_state = 43, .external_lex_state = 3}, + [1617] = {.lex_state = 43}, + [1618] = {.lex_state = 43, .external_lex_state = 3}, + [1619] = {.lex_state = 43}, + [1620] = {.lex_state = 43}, + [1621] = {.lex_state = 43}, + [1622] = {.lex_state = 43}, + [1623] = {.lex_state = 43, .external_lex_state = 3}, + [1624] = {.lex_state = 8}, + [1625] = {.lex_state = 43}, + [1626] = {.lex_state = 43}, + [1627] = {.lex_state = 43}, + [1628] = {.lex_state = 43}, + [1629] = {.lex_state = 22}, + [1630] = {.lex_state = 43, .external_lex_state = 3}, + [1631] = {.lex_state = 43}, + [1632] = {.lex_state = 43}, + [1633] = {.lex_state = 43, .external_lex_state = 3}, + [1634] = {.lex_state = 43, .external_lex_state = 3}, + [1635] = {.lex_state = 43}, + [1636] = {.lex_state = 43, .external_lex_state = 3}, + [1637] = {.lex_state = 8}, + [1638] = {.lex_state = 43}, + [1639] = {.lex_state = 43}, + [1640] = {.lex_state = 43, .external_lex_state = 3}, + [1641] = {.lex_state = 43, .external_lex_state = 3}, + [1642] = {.lex_state = 22}, + [1643] = {.lex_state = 43}, + [1644] = {.lex_state = 43, .external_lex_state = 3}, + [1645] = {.lex_state = 43}, + [1646] = {.lex_state = 43}, + [1647] = {.lex_state = 10}, + [1648] = {.lex_state = 43}, + [1649] = {.lex_state = 43}, + [1650] = {.lex_state = 43, .external_lex_state = 3}, + [1651] = {.lex_state = 43}, + [1652] = {.lex_state = 8}, + [1653] = {.lex_state = 43}, + [1654] = {.lex_state = 43}, + [1655] = {.lex_state = 43}, + [1656] = {.lex_state = 43}, + [1657] = {.lex_state = 43}, + [1658] = {.lex_state = 43}, + [1659] = {.lex_state = 43}, + [1660] = {.lex_state = 43}, + [1661] = {.lex_state = 43, .external_lex_state = 3}, + [1662] = {.lex_state = 43}, + [1663] = {.lex_state = 43}, + [1664] = {.lex_state = 43}, + [1665] = {.lex_state = 43}, + [1666] = {.lex_state = 43}, + [1667] = {.lex_state = 43, .external_lex_state = 3}, + [1668] = {.lex_state = 8}, + [1669] = {.lex_state = 43}, + [1670] = {.lex_state = 43}, + [1671] = {.lex_state = 43, .external_lex_state = 3}, + [1672] = {.lex_state = 43}, + [1673] = {.lex_state = 43}, + [1674] = {.lex_state = 43}, + [1675] = {.lex_state = 43}, + [1676] = {.lex_state = 43}, + [1677] = {.lex_state = 22}, + [1678] = {.lex_state = 43}, + [1679] = {.lex_state = 43}, + [1680] = {.lex_state = 43}, + [1681] = {.lex_state = 43}, + [1682] = {.lex_state = 22}, + [1683] = {.lex_state = 43}, + [1684] = {.lex_state = 43}, + [1685] = {.lex_state = 43}, + [1686] = {.lex_state = 43}, + [1687] = {.lex_state = 43}, + [1688] = {.lex_state = 43}, + [1689] = {.lex_state = 43}, + [1690] = {.lex_state = 43}, + [1691] = {.lex_state = 22}, + [1692] = {.lex_state = 43}, + [1693] = {.lex_state = 43}, + [1694] = {.lex_state = 43}, + [1695] = {.lex_state = 8}, + [1696] = {.lex_state = 43, .external_lex_state = 3}, + [1697] = {.lex_state = 43}, + [1698] = {.lex_state = 43}, + [1699] = {.lex_state = 43}, + [1700] = {.lex_state = 43}, + [1701] = {.lex_state = 8}, [1702] = {.lex_state = 8}, - [1703] = {.lex_state = 41, .external_lex_state = 3}, - [1704] = {.lex_state = 41}, - [1705] = {.lex_state = 41}, - [1706] = {.lex_state = 41}, - [1707] = {.lex_state = 41}, - [1708] = {.lex_state = 8}, - [1709] = {.lex_state = 8}, - [1710] = {.lex_state = 41}, - [1711] = {.lex_state = 8}, - [1712] = {.lex_state = 41}, - [1713] = {.lex_state = 41, .external_lex_state = 3}, - [1714] = {.lex_state = 41}, - [1715] = {.lex_state = 41}, - [1716] = {.lex_state = 41, .external_lex_state = 3}, - [1717] = {.lex_state = 41}, - [1718] = {.lex_state = 9}, - [1719] = {.lex_state = 41}, - [1720] = {.lex_state = 41}, - [1721] = {.lex_state = 41, .external_lex_state = 3}, - [1722] = {.lex_state = 41}, - [1723] = {.lex_state = 41}, - [1724] = {.lex_state = 41}, - [1725] = {.lex_state = 41}, - [1726] = {.lex_state = 41}, - [1727] = {.lex_state = 41, .external_lex_state = 3}, - [1728] = {.lex_state = 41}, - [1729] = {.lex_state = 16}, - [1730] = {.lex_state = 41}, - [1731] = {.lex_state = 41}, - [1732] = {.lex_state = 41}, - [1733] = {.lex_state = 41, .external_lex_state = 3}, - [1734] = {.lex_state = 41, .external_lex_state = 3}, - [1735] = {.lex_state = 41}, - [1736] = {.lex_state = 41}, - [1737] = {.lex_state = 8}, - [1738] = {.lex_state = 41, .external_lex_state = 3}, - [1739] = {.lex_state = 41}, - [1740] = {.lex_state = 8}, - [1741] = {.lex_state = 41}, - [1742] = {.lex_state = 41, .external_lex_state = 3}, - [1743] = {.lex_state = 41}, - [1744] = {.lex_state = 8}, - [1745] = {.lex_state = 41}, - [1746] = {.lex_state = 41}, - [1747] = {.lex_state = 41}, - [1748] = {.lex_state = 41}, - [1749] = {.lex_state = 41}, - [1750] = {.lex_state = 41, .external_lex_state = 3}, - [1751] = {.lex_state = 16}, - [1752] = {.lex_state = 41}, - [1753] = {.lex_state = 41}, - [1754] = {.lex_state = 41}, - [1755] = {.lex_state = 41}, - [1756] = {.lex_state = 8}, - [1757] = {.lex_state = 41}, - [1758] = {.lex_state = 41}, - [1759] = {.lex_state = 41}, - [1760] = {.lex_state = 41, .external_lex_state = 3}, + [1703] = {.lex_state = 43}, + [1704] = {.lex_state = 8}, + [1705] = {.lex_state = 43, .external_lex_state = 3}, + [1706] = {.lex_state = 43, .external_lex_state = 3}, + [1707] = {.lex_state = 43}, + [1708] = {.lex_state = 43}, + [1709] = {.lex_state = 43, .external_lex_state = 3}, + [1710] = {.lex_state = 43}, + [1711] = {.lex_state = 43}, + [1712] = {.lex_state = 43}, + [1713] = {.lex_state = 43}, + [1714] = {.lex_state = 43}, + [1715] = {.lex_state = 43}, + [1716] = {.lex_state = 43}, + [1717] = {.lex_state = 43}, + [1718] = {.lex_state = 43}, + [1719] = {.lex_state = 43}, + [1720] = {.lex_state = 43}, + [1721] = {.lex_state = 43}, + [1722] = {.lex_state = 43, .external_lex_state = 3}, + [1723] = {.lex_state = 43}, + [1724] = {.lex_state = 43}, + [1725] = {.lex_state = 43}, + [1726] = {.lex_state = 43, .external_lex_state = 3}, + [1727] = {.lex_state = 43, .external_lex_state = 3}, + [1728] = {.lex_state = 43}, + [1729] = {.lex_state = 43}, + [1730] = {.lex_state = 8}, + [1731] = {.lex_state = 43, .external_lex_state = 3}, + [1732] = {.lex_state = 43}, + [1733] = {.lex_state = 8}, + [1734] = {.lex_state = 22}, + [1735] = {.lex_state = 43, .external_lex_state = 3}, + [1736] = {.lex_state = 43, .external_lex_state = 3}, + [1737] = {.lex_state = 43, .external_lex_state = 3}, + [1738] = {.lex_state = 43}, + [1739] = {.lex_state = 43}, + [1740] = {.lex_state = 43}, + [1741] = {.lex_state = 43}, + [1742] = {.lex_state = 43}, + [1743] = {.lex_state = 43, .external_lex_state = 3}, + [1744] = {.lex_state = 43}, + [1745] = {.lex_state = 43}, + [1746] = {.lex_state = 43, .external_lex_state = 3}, + [1747] = {.lex_state = 43}, + [1748] = {.lex_state = 43}, + [1749] = {.lex_state = 8}, + [1750] = {.lex_state = 43}, + [1751] = {.lex_state = 43}, + [1752] = {.lex_state = 43, .external_lex_state = 3}, + [1753] = {.lex_state = 43}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -7474,20 +7518,21 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), [sym__call_open_gap] = ACTIONS(1), [sym__statement_break] = ACTIONS(1), + [sym__type_application_ahead] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(1650), + [sym_source_file] = STATE(1394), [sym_statement] = STATE(7), - [sym_import_statement] = STATE(1379), - [sym_namespace_declaration] = STATE(1379), - [sym_let_declaration] = STATE(1379), - [sym_assignment] = STATE(1379), - [sym_function_declaration] = STATE(1379), - [sym_extern_declaration] = STATE(1379), - [sym_type_declaration] = STATE(1379), - [sym_effect_declaration] = STATE(1379), - [sym_expression_statement] = STATE(1379), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1404), + [sym_namespace_declaration] = STATE(1404), + [sym_let_declaration] = STATE(1404), + [sym_assignment] = STATE(1404), + [sym_function_declaration] = STATE(1404), + [sym_extern_declaration] = STATE(1404), + [sym_type_declaration] = STATE(1404), + [sym_effect_declaration] = STATE(1404), + [sym_expression_statement] = STATE(1404), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -7514,8 +7559,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1379), - [sym_signature_declaration] = STATE(1379), + [sym_module_declaration] = STATE(1404), + [sym_signature_declaration] = STATE(1404), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -7565,15 +7610,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [2] = { [sym_statement] = STATE(14), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(467), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -7595,17 +7640,17 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_resume_expression] = STATE(525), [sym_type_constructor] = STATE(525), [sym_update_expression] = STATE(525), - [sym_field_assignments] = STATE(1590), - [sym_field_assignment] = STATE(1132), + [sym_field_assignments] = STATE(1575), + [sym_field_assignment] = STATE(1121), [sym_block] = STATE(525), [sym_object_literal] = STATE(525), [sym_lambda_expression] = STATE(525), [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_map_entry] = STATE(1210), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_map_entry] = STATE(1178), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -7655,15 +7700,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [3] = { [sym_statement] = STATE(17), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(462), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -7685,17 +7730,17 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_resume_expression] = STATE(525), [sym_type_constructor] = STATE(525), [sym_update_expression] = STATE(525), - [sym_field_assignments] = STATE(1492), - [sym_field_assignment] = STATE(1132), + [sym_field_assignments] = STATE(1487), + [sym_field_assignment] = STATE(1121), [sym_block] = STATE(525), [sym_object_literal] = STATE(525), [sym_lambda_expression] = STATE(525), [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_map_entry] = STATE(1129), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_map_entry] = STATE(1123), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -7745,15 +7790,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [4] = { [sym_statement] = STATE(8), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(445), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -7775,17 +7820,17 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_resume_expression] = STATE(525), [sym_type_constructor] = STATE(525), [sym_update_expression] = STATE(525), - [sym_field_assignments] = STATE(1625), - [sym_field_assignment] = STATE(1132), + [sym_field_assignments] = STATE(1687), + [sym_field_assignment] = STATE(1121), [sym_block] = STATE(525), [sym_object_literal] = STATE(525), [sym_lambda_expression] = STATE(525), [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_map_entry] = STATE(1254), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_map_entry] = STATE(1147), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -7906,7 +7951,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_recv] = ACTIONS(119), [anon_sym_perform] = ACTIONS(121), [anon_sym_resume] = ACTIONS(123), - [anon_sym_LT2] = ACTIONS(87), [anon_sym_state] = ACTIONS(87), [anon_sym_module] = ACTIONS(87), [anon_sym_export] = ACTIONS(87), @@ -7920,19 +7964,20 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__doc_comment_line] = ACTIONS(83), [sym_line_comment] = ACTIONS(3), [sym__call_open_gap] = ACTIONS(83), + [sym__type_application_ahead] = ACTIONS(83), }, [6] = { [sym_statement] = STATE(6), - [sym_import_statement] = STATE(1379), - [sym_namespace_declaration] = STATE(1379), - [sym_let_declaration] = STATE(1379), - [sym_assignment] = STATE(1379), - [sym_function_declaration] = STATE(1379), - [sym_extern_declaration] = STATE(1379), - [sym_type_declaration] = STATE(1379), - [sym_effect_declaration] = STATE(1379), - [sym_expression_statement] = STATE(1379), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1404), + [sym_namespace_declaration] = STATE(1404), + [sym_let_declaration] = STATE(1404), + [sym_assignment] = STATE(1404), + [sym_function_declaration] = STATE(1404), + [sym_extern_declaration] = STATE(1404), + [sym_type_declaration] = STATE(1404), + [sym_effect_declaration] = STATE(1404), + [sym_expression_statement] = STATE(1404), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -7959,8 +8004,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1379), - [sym_signature_declaration] = STATE(1379), + [sym_module_declaration] = STATE(1404), + [sym_signature_declaration] = STATE(1404), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8010,16 +8055,16 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [7] = { [sym_statement] = STATE(6), - [sym_import_statement] = STATE(1379), - [sym_namespace_declaration] = STATE(1379), - [sym_let_declaration] = STATE(1379), - [sym_assignment] = STATE(1379), - [sym_function_declaration] = STATE(1379), - [sym_extern_declaration] = STATE(1379), - [sym_type_declaration] = STATE(1379), - [sym_effect_declaration] = STATE(1379), - [sym_expression_statement] = STATE(1379), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1404), + [sym_namespace_declaration] = STATE(1404), + [sym_let_declaration] = STATE(1404), + [sym_assignment] = STATE(1404), + [sym_function_declaration] = STATE(1404), + [sym_extern_declaration] = STATE(1404), + [sym_type_declaration] = STATE(1404), + [sym_effect_declaration] = STATE(1404), + [sym_expression_statement] = STATE(1404), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -8046,8 +8091,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1379), - [sym_signature_declaration] = STATE(1379), + [sym_module_declaration] = STATE(1404), + [sym_signature_declaration] = STATE(1404), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8097,15 +8142,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [8] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(522), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8133,8 +8178,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8184,16 +8229,16 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [9] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -8220,8 +8265,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8271,16 +8316,16 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [10] = { [sym_statement] = STATE(11), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -8307,8 +8352,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8358,16 +8403,16 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [11] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), - [sym_expression] = STATE(610), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), + [sym_expression] = STATE(568), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -8394,8 +8439,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8445,15 +8490,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [12] = { [sym_statement] = STATE(16), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(487), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8481,8 +8526,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8532,15 +8577,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [13] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(515), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8568,8 +8613,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8619,15 +8664,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [14] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(481), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8655,8 +8700,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8706,15 +8751,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [15] = { [sym_statement] = STATE(13), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(495), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8742,8 +8787,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8793,15 +8838,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [16] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(507), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8829,8 +8874,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -8880,15 +8925,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [17] = { [sym_statement] = STATE(9), - [sym_import_statement] = STATE(1760), - [sym_namespace_declaration] = STATE(1760), - [sym_let_declaration] = STATE(1760), - [sym_assignment] = STATE(1760), - [sym_function_declaration] = STATE(1760), - [sym_extern_declaration] = STATE(1760), - [sym_type_declaration] = STATE(1760), - [sym_effect_declaration] = STATE(1760), - [sym_expression_statement] = STATE(1760), + [sym_import_statement] = STATE(1563), + [sym_namespace_declaration] = STATE(1563), + [sym_let_declaration] = STATE(1563), + [sym_assignment] = STATE(1563), + [sym_function_declaration] = STATE(1563), + [sym_extern_declaration] = STATE(1563), + [sym_type_declaration] = STATE(1563), + [sym_effect_declaration] = STATE(1563), + [sym_expression_statement] = STATE(1563), [sym_expression] = STATE(513), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), @@ -8916,8 +8961,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_literal] = STATE(525), [sym_list_literal] = STATE(510), [sym_map_literal] = STATE(510), - [sym_module_declaration] = STATE(1760), - [sym_signature_declaration] = STATE(1760), + [sym_module_declaration] = STATE(1563), + [sym_signature_declaration] = STATE(1563), [sym_qualified_path] = STATE(450), [sym_boolean] = STATE(510), [sym_doc_comment] = STATE(20), @@ -9039,7 +9084,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_recv] = ACTIONS(286), [anon_sym_perform] = ACTIONS(288), [anon_sym_resume] = ACTIONS(290), - [anon_sym_LT2] = ACTIONS(87), [anon_sym_true] = ACTIONS(292), [anon_sym_false] = ACTIONS(292), [sym_float] = ACTIONS(294), @@ -9048,6 +9092,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_interpolated_string] = ACTIONS(296), [sym_line_comment] = ACTIONS(298), [sym__call_open_gap] = ACTIONS(83), + [sym__type_application_ahead] = ACTIONS(83), }, [19] = { [sym_expression] = STATE(444), @@ -9117,7 +9162,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_recv] = ACTIONS(53), [anon_sym_perform] = ACTIONS(55), [anon_sym_resume] = ACTIONS(57), - [anon_sym_LT2] = ACTIONS(87), [anon_sym_true] = ACTIONS(65), [anon_sym_false] = ACTIONS(65), [sym_float] = ACTIONS(67), @@ -9127,9 +9171,10 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(298), [sym__call_open_gap] = ACTIONS(83), [sym__statement_break] = ACTIONS(83), + [sym__type_application_ahead] = ACTIONS(83), }, [20] = { - [sym_expression] = STATE(535), + [sym_expression] = STATE(537), [sym_match_expression] = STATE(502), [sym_if_expression] = STATE(502), [sym_handler_expression] = STATE(502), @@ -9247,11 +9292,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1526), 1, + STATE(1521), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9341,11 +9386,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1391), 1, + STATE(1386), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9435,11 +9480,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, - STATE(1728), 1, + STATE(1732), 1, sym_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9529,11 +9574,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1435), 1, + STATE(1430), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9623,11 +9668,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1392), 1, + STATE(1387), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9717,11 +9762,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1455), 1, + STATE(1450), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9811,11 +9856,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1382), 1, + STATE(1388), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9905,11 +9950,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1537), 1, + STATE(1532), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -9999,11 +10044,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1567), 1, - sym_argument_list, STATE(1568), 1, + sym_argument_list, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -10093,11 +10138,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1527), 1, + STATE(1522), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -10187,11 +10232,11 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1541), 1, + STATE(1536), 1, sym_argument_list, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, ACTIONS(292), 2, anon_sym_true, @@ -10281,9 +10326,9 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(441), 1, sym_expression, - STATE(1214), 1, + STATE(1262), 1, sym_named_argument, - STATE(1568), 1, + STATE(1577), 1, sym_named_argument_list, STATE(1627), 1, sym_argument_list, @@ -10373,7 +10418,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(235), 1, sym_qualified_path, - STATE(573), 1, + STATE(574), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10461,7 +10506,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(235), 1, sym_qualified_path, - STATE(548), 1, + STATE(550), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10547,9 +10592,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(541), 1, + STATE(544), 1, sym_expression, - STATE(1347), 1, + STATE(1343), 1, sym_map_entry, ACTIONS(292), 2, anon_sym_true, @@ -10725,7 +10770,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, STATE(235), 1, sym_qualified_path, - STATE(550), 1, + STATE(552), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -10901,7 +10946,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, STATE(235), 1, sym_qualified_path, - STATE(539), 1, + STATE(541), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11163,9 +11208,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(235), 1, sym_qualified_path, - STATE(562), 1, + STATE(565), 1, sym_expression, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -11339,9 +11384,9 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(235), 1, sym_qualified_path, - STATE(603), 1, + STATE(527), 1, sym_expression, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -11429,7 +11474,7 @@ static const uint16_t ts_small_parse_table[] = { sym_qualified_path, STATE(605), 1, sym_expression, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(292), 2, anon_sym_true, @@ -11515,7 +11560,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(587), 1, + STATE(586), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11601,7 +11646,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(554), 1, + STATE(558), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -11773,7 +11818,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(531), 1, + STATE(533), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -11859,7 +11904,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(538), 1, + STATE(540), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12031,7 +12076,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(568), 1, + STATE(570), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12117,7 +12162,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(561), 1, + STATE(564), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -12805,7 +12850,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(549), 1, + STATE(551), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -12977,7 +13022,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(569), 1, + STATE(610), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13063,7 +13108,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(570), 1, + STATE(572), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13235,7 +13280,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(595), 1, + STATE(596), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13321,7 +13366,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(592), 1, + STATE(591), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13407,7 +13452,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(527), 1, + STATE(592), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13579,7 +13624,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(596), 1, + STATE(597), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13665,7 +13710,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(597), 1, + STATE(599), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -13751,7 +13796,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(599), 1, + STATE(600), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -14095,7 +14140,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(608), 1, + STATE(609), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14181,7 +14226,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(593), 1, + STATE(602), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14267,7 +14312,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(565), 1, + STATE(571), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14353,9 +14398,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(534), 1, + STATE(536), 1, sym_call_expression, - STATE(622), 1, + STATE(612), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -14440,7 +14485,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(533), 1, + STATE(535), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14526,7 +14571,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(542), 1, + STATE(545), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14612,7 +14657,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(588), 1, + STATE(590), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14698,7 +14743,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(589), 1, + STATE(593), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14784,7 +14829,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(530), 1, + STATE(532), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14870,7 +14915,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(532), 1, + STATE(534), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -14956,7 +15001,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(536), 1, + STATE(538), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15042,7 +15087,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(537), 1, + STATE(539), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15128,7 +15173,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(540), 1, + STATE(543), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15214,7 +15259,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(544), 1, + STATE(546), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15300,7 +15345,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(557), 1, + STATE(559), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15386,7 +15431,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(560), 1, + STATE(563), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15472,7 +15517,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(572), 1, + STATE(579), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15558,7 +15603,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(574), 1, + STATE(582), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15644,7 +15689,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(579), 1, + STATE(587), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15730,7 +15775,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(585), 1, + STATE(589), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15816,7 +15861,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(590), 1, + STATE(594), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15902,7 +15947,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(591), 1, + STATE(595), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -15988,7 +16033,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(600), 1, + STATE(608), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16074,7 +16119,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(601), 1, + STATE(528), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -16160,7 +16205,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(529), 1, + STATE(531), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -18396,7 +18441,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(626), 1, + STATE(611), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -19772,7 +19817,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(564), 1, + STATE(567), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23556,7 +23601,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(609), 1, + STATE(529), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23642,7 +23687,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(625), 1, + STATE(620), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -23900,7 +23945,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(613), 1, + STATE(615), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24072,7 +24117,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, STATE(450), 1, sym_qualified_path, - STATE(582), 1, + STATE(588), 1, sym_expression, ACTIONS(65), 2, anon_sym_true, @@ -24760,7 +24805,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(555), 1, + STATE(556), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -24846,7 +24891,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(567), 1, + STATE(569), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25018,7 +25063,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(543), 1, + STATE(542), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25104,7 +25149,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(546), 1, + STATE(548), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25190,7 +25235,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(547), 1, + STATE(549), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25276,7 +25321,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(551), 1, + STATE(553), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25362,7 +25407,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(556), 1, + STATE(557), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25448,7 +25493,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(563), 1, + STATE(562), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -25620,7 +25665,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(571), 1, + STATE(573), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26050,7 +26095,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(586), 1, + STATE(585), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26222,7 +26267,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(616), 1, + STATE(614), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26308,7 +26353,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(619), 1, + STATE(618), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26394,7 +26439,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(602), 1, + STATE(601), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -26824,7 +26869,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, STATE(235), 1, sym_qualified_path, - STATE(624), 1, + STATE(626), 1, sym_expression, ACTIONS(292), 2, anon_sym_true, @@ -27063,14 +27108,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(409), 1, anon_sym_LBRACE, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, STATE(232), 1, aux_sym_qualified_path_repeat1, - STATE(1690), 1, + STATE(1683), 1, sym_type_arguments, - ACTIONS(403), 14, + ACTIONS(403), 13, anon_sym_COLON, - anon_sym_LT, anon_sym_GT, anon_sym__, anon_sym_in, @@ -27083,8 +27127,9 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(405), 21, + ACTIONS(405), 22, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -27202,7 +27247,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(231), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 15, + ACTIONS(419), 14, anon_sym_COLON, anon_sym_LT, anon_sym_GT, @@ -27211,15 +27256,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(421), 22, + ACTIONS(421), 23, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -27248,7 +27293,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(231), 1, aux_sym_qualified_path_repeat1, - ACTIONS(426), 15, + ACTIONS(426), 14, anon_sym_COLON, anon_sym_LT, anon_sym_GT, @@ -27257,15 +27302,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(428), 22, + ACTIONS(428), 23, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -27307,10 +27352,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27365,10 +27410,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27407,13 +27452,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(298), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(466), 1, anon_sym_LBRACE, - STATE(1690), 1, + STATE(1683), 1, sym_type_arguments, - ACTIONS(403), 13, - anon_sym_LT, + ACTIONS(403), 12, anon_sym_GT, anon_sym__, anon_sym_in, @@ -27426,8 +27470,9 @@ static const uint16_t ts_small_parse_table[] = { sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(405), 22, + ACTIONS(405), 23, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -27457,10 +27502,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(469), 13, anon_sym_LT, @@ -27517,10 +27562,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27575,10 +27620,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27616,7 +27661,7 @@ static const uint16_t ts_small_parse_table[] = { [24335] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(419), 15, + ACTIONS(419), 14, anon_sym_COLON, anon_sym_LT, anon_sym_GT, @@ -27625,15 +27670,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(421), 23, + ACTIONS(421), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -27666,10 +27711,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(481), 13, anon_sym_LT, @@ -27717,10 +27762,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27771,10 +27816,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27824,10 +27869,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27878,10 +27923,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -27925,10 +27970,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(485), 13, anon_sym_LT, @@ -27983,12 +28028,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(491), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28043,10 +28088,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28099,10 +28144,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28156,12 +28201,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(506), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28216,10 +28261,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28272,10 +28317,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28329,12 +28374,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(521), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28389,10 +28434,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28445,12 +28490,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(532), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28505,10 +28550,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28561,12 +28606,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(543), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -28604,7 +28649,7 @@ static const uint16_t ts_small_parse_table[] = { [25591] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(548), 14, + ACTIONS(548), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28612,15 +28657,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(550), 23, + ACTIONS(550), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28646,7 +28691,7 @@ static const uint16_t ts_small_parse_table[] = { [25636] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(552), 14, + ACTIONS(552), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28654,15 +28699,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(554), 23, + ACTIONS(554), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28688,7 +28733,7 @@ static const uint16_t ts_small_parse_table[] = { [25681] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(556), 14, + ACTIONS(556), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28696,15 +28741,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(558), 23, + ACTIONS(558), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28730,7 +28775,7 @@ static const uint16_t ts_small_parse_table[] = { [25726] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(560), 14, + ACTIONS(560), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28738,15 +28783,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(562), 23, + ACTIONS(562), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28772,7 +28817,7 @@ static const uint16_t ts_small_parse_table[] = { [25771] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(564), 14, + ACTIONS(564), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28780,15 +28825,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(566), 23, + ACTIONS(566), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28814,7 +28859,7 @@ static const uint16_t ts_small_parse_table[] = { [25816] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(568), 14, + ACTIONS(568), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28822,15 +28867,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(570), 23, + ACTIONS(570), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28856,7 +28901,7 @@ static const uint16_t ts_small_parse_table[] = { [25861] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(572), 14, + ACTIONS(572), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28864,15 +28909,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(574), 23, + ACTIONS(574), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28898,7 +28943,7 @@ static const uint16_t ts_small_parse_table[] = { [25906] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(576), 14, + ACTIONS(576), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28906,15 +28951,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(579), 23, + ACTIONS(579), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28940,7 +28985,7 @@ static const uint16_t ts_small_parse_table[] = { [25951] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 14, + ACTIONS(582), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28948,15 +28993,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(584), 23, + ACTIONS(584), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28982,7 +29027,7 @@ static const uint16_t ts_small_parse_table[] = { [25996] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(586), 14, + ACTIONS(586), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -28990,15 +29035,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(588), 23, + ACTIONS(588), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29024,7 +29069,7 @@ static const uint16_t ts_small_parse_table[] = { [26041] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(590), 14, + ACTIONS(590), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29032,15 +29077,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(593), 23, + ACTIONS(593), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29066,7 +29111,7 @@ static const uint16_t ts_small_parse_table[] = { [26086] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(596), 14, + ACTIONS(596), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29074,15 +29119,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(598), 23, + ACTIONS(598), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29108,7 +29153,7 @@ static const uint16_t ts_small_parse_table[] = { [26131] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(600), 14, + ACTIONS(600), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29116,15 +29161,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(602), 23, + ACTIONS(602), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29150,7 +29195,7 @@ static const uint16_t ts_small_parse_table[] = { [26176] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(604), 14, + ACTIONS(604), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29158,15 +29203,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(606), 23, + ACTIONS(606), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29192,7 +29237,7 @@ static const uint16_t ts_small_parse_table[] = { [26221] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(608), 14, + ACTIONS(608), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29200,15 +29245,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(610), 23, + ACTIONS(610), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29234,7 +29279,7 @@ static const uint16_t ts_small_parse_table[] = { [26266] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(612), 14, + ACTIONS(612), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29242,15 +29287,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(614), 23, + ACTIONS(614), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29276,7 +29321,7 @@ static const uint16_t ts_small_parse_table[] = { [26311] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(616), 14, + ACTIONS(616), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29284,15 +29329,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(618), 23, + ACTIONS(618), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29318,7 +29363,7 @@ static const uint16_t ts_small_parse_table[] = { [26356] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(620), 14, + ACTIONS(620), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29326,15 +29371,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(622), 23, + ACTIONS(622), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29360,7 +29405,7 @@ static const uint16_t ts_small_parse_table[] = { [26401] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(624), 14, + ACTIONS(624), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29368,15 +29413,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(626), 23, + ACTIONS(626), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29402,7 +29447,7 @@ static const uint16_t ts_small_parse_table[] = { [26446] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(628), 14, + ACTIONS(628), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29410,15 +29455,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(630), 23, + ACTIONS(630), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29444,7 +29489,7 @@ static const uint16_t ts_small_parse_table[] = { [26491] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(632), 14, + ACTIONS(632), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29452,15 +29497,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(634), 23, + ACTIONS(634), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29486,7 +29531,7 @@ static const uint16_t ts_small_parse_table[] = { [26536] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(636), 14, + ACTIONS(636), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29494,15 +29539,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(638), 23, + ACTIONS(638), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29528,7 +29573,7 @@ static const uint16_t ts_small_parse_table[] = { [26581] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(640), 14, + ACTIONS(640), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29536,15 +29581,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(642), 23, + ACTIONS(642), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29570,7 +29615,7 @@ static const uint16_t ts_small_parse_table[] = { [26626] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(644), 14, + ACTIONS(644), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29578,15 +29623,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(646), 23, + ACTIONS(646), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29612,7 +29657,7 @@ static const uint16_t ts_small_parse_table[] = { [26671] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(648), 14, + ACTIONS(648), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29620,15 +29665,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(651), 23, + ACTIONS(651), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29654,7 +29699,7 @@ static const uint16_t ts_small_parse_table[] = { [26716] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(654), 14, + ACTIONS(654), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29662,15 +29707,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(656), 23, + ACTIONS(656), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29696,7 +29741,7 @@ static const uint16_t ts_small_parse_table[] = { [26761] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(658), 14, + ACTIONS(658), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29704,15 +29749,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(660), 23, + ACTIONS(660), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29738,7 +29783,7 @@ static const uint16_t ts_small_parse_table[] = { [26806] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(662), 14, + ACTIONS(662), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29746,15 +29791,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(664), 23, + ACTIONS(664), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29780,7 +29825,7 @@ static const uint16_t ts_small_parse_table[] = { [26851] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(666), 14, + ACTIONS(666), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29788,15 +29833,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(668), 23, + ACTIONS(668), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29822,7 +29867,7 @@ static const uint16_t ts_small_parse_table[] = { [26896] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(670), 14, + ACTIONS(670), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29830,15 +29875,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(672), 23, + ACTIONS(672), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29864,7 +29909,7 @@ static const uint16_t ts_small_parse_table[] = { [26941] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(674), 14, + ACTIONS(674), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29872,15 +29917,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(676), 23, + ACTIONS(676), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29906,7 +29951,7 @@ static const uint16_t ts_small_parse_table[] = { [26986] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(678), 14, + ACTIONS(678), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29914,15 +29959,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(680), 23, + ACTIONS(680), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29948,7 +29993,7 @@ static const uint16_t ts_small_parse_table[] = { [27031] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(682), 14, + ACTIONS(682), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29956,15 +30001,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(684), 23, + ACTIONS(684), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -29990,7 +30035,7 @@ static const uint16_t ts_small_parse_table[] = { [27076] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(686), 14, + ACTIONS(686), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -29998,15 +30043,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(688), 23, + ACTIONS(688), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30032,7 +30077,7 @@ static const uint16_t ts_small_parse_table[] = { [27121] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(690), 14, + ACTIONS(690), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -30040,15 +30085,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(692), 23, + ACTIONS(692), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30074,7 +30119,7 @@ static const uint16_t ts_small_parse_table[] = { [27166] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(694), 14, + ACTIONS(694), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -30082,15 +30127,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(696), 23, + ACTIONS(696), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30116,7 +30161,7 @@ static const uint16_t ts_small_parse_table[] = { [27211] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(403), 14, + ACTIONS(403), 13, anon_sym_LT, anon_sym_GT, anon_sym__, @@ -30124,15 +30169,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_do, anon_sym_SLASH, - anon_sym_LT2, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(405), 23, + ACTIONS(405), 24, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30159,21 +30204,21 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(698), 1, anon_sym_COLON_COLON, ACTIONS(700), 1, anon_sym_LBRACE, STATE(296), 1, aux_sym_qualified_path_repeat1, - STATE(1717), 1, + STATE(1710), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 28, + ACTIONS(405), 29, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -30208,13 +30253,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(295), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 4, + ACTIONS(419), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(421), 29, + ACTIONS(421), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30250,13 +30295,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(295), 1, aux_sym_qualified_path_repeat1, - ACTIONS(426), 4, + ACTIONS(426), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(428), 29, + ACTIONS(428), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -30288,8 +30333,8 @@ static const uint16_t ts_small_parse_table[] = { [27404] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30308,7 +30353,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30341,8 +30386,8 @@ static const uint16_t ts_small_parse_table[] = { [27474] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30361,7 +30406,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30394,8 +30439,8 @@ static const uint16_t ts_small_parse_table[] = { [27544] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30414,7 +30459,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30447,8 +30492,8 @@ static const uint16_t ts_small_parse_table[] = { [27614] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30467,7 +30512,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30500,8 +30545,8 @@ static const uint16_t ts_small_parse_table[] = { [27684] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30520,7 +30565,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30553,8 +30598,8 @@ static const uint16_t ts_small_parse_table[] = { [27754] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30573,7 +30618,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30606,8 +30651,8 @@ static const uint16_t ts_small_parse_table[] = { [27824] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30626,7 +30671,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30659,8 +30704,8 @@ static const uint16_t ts_small_parse_table[] = { [27894] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30679,7 +30724,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30712,8 +30757,8 @@ static const uint16_t ts_small_parse_table[] = { [27964] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30732,7 +30777,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30765,8 +30810,8 @@ static const uint16_t ts_small_parse_table[] = { [28034] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30785,7 +30830,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30818,8 +30863,8 @@ static const uint16_t ts_small_parse_table[] = { [28104] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30838,7 +30883,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30871,8 +30916,8 @@ static const uint16_t ts_small_parse_table[] = { [28174] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30891,7 +30936,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30924,8 +30969,8 @@ static const uint16_t ts_small_parse_table[] = { [28244] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30944,7 +30989,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -30977,8 +31022,8 @@ static const uint16_t ts_small_parse_table[] = { [28314] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -30997,7 +31042,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31030,8 +31075,8 @@ static const uint16_t ts_small_parse_table[] = { [28384] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31050,7 +31095,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31083,8 +31128,8 @@ static const uint16_t ts_small_parse_table[] = { [28454] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31103,7 +31148,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31136,8 +31181,8 @@ static const uint16_t ts_small_parse_table[] = { [28524] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31156,7 +31201,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31189,8 +31234,8 @@ static const uint16_t ts_small_parse_table[] = { [28594] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31209,7 +31254,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31242,8 +31287,8 @@ static const uint16_t ts_small_parse_table[] = { [28664] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31262,7 +31307,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31295,8 +31340,8 @@ static const uint16_t ts_small_parse_table[] = { [28734] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31315,7 +31360,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31348,8 +31393,8 @@ static const uint16_t ts_small_parse_table[] = { [28804] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31368,7 +31413,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31401,8 +31446,8 @@ static const uint16_t ts_small_parse_table[] = { [28874] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31421,7 +31466,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31454,8 +31499,8 @@ static const uint16_t ts_small_parse_table[] = { [28944] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31474,7 +31519,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31507,8 +31552,8 @@ static const uint16_t ts_small_parse_table[] = { [29014] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31527,7 +31572,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31560,8 +31605,8 @@ static const uint16_t ts_small_parse_table[] = { [29084] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31580,7 +31625,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31613,8 +31658,8 @@ static const uint16_t ts_small_parse_table[] = { [29154] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31633,7 +31678,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31666,8 +31711,8 @@ static const uint16_t ts_small_parse_table[] = { [29224] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31686,7 +31731,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31719,8 +31764,8 @@ static const uint16_t ts_small_parse_table[] = { [29294] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31739,7 +31784,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31772,8 +31817,8 @@ static const uint16_t ts_small_parse_table[] = { [29364] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31792,7 +31837,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31825,8 +31870,8 @@ static const uint16_t ts_small_parse_table[] = { [29434] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31845,7 +31890,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31878,8 +31923,8 @@ static const uint16_t ts_small_parse_table[] = { [29504] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31898,7 +31943,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31931,8 +31976,8 @@ static const uint16_t ts_small_parse_table[] = { [29574] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -31951,7 +31996,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -31984,8 +32029,8 @@ static const uint16_t ts_small_parse_table[] = { [29644] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32004,7 +32049,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32038,17 +32083,17 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(798), 1, anon_sym_LBRACE, - STATE(1717), 1, + STATE(1710), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 28, + ACTIONS(405), 29, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -32079,8 +32124,8 @@ static const uint16_t ts_small_parse_table[] = { [29762] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32099,7 +32144,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32132,15 +32177,15 @@ static const uint16_t ts_small_parse_table[] = { [29832] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(730), 1, anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(469), 3, anon_sym_LT, @@ -32176,8 +32221,8 @@ static const uint16_t ts_small_parse_table[] = { [29884] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32196,7 +32241,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32229,8 +32274,8 @@ static const uint16_t ts_small_parse_table[] = { [29954] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32249,7 +32294,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32282,8 +32327,8 @@ static const uint16_t ts_small_parse_table[] = { [30024] = 9, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(728), 1, @@ -32292,7 +32337,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(481), 3, anon_sym_LT, @@ -32327,8 +32372,8 @@ static const uint16_t ts_small_parse_table[] = { [30078] = 12, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(726), 1, @@ -32339,7 +32384,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(481), 2, anon_sym_LT, @@ -32375,8 +32420,8 @@ static const uint16_t ts_small_parse_table[] = { [30138] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32395,7 +32440,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32428,8 +32473,8 @@ static const uint16_t ts_small_parse_table[] = { [30208] = 13, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(726), 1, @@ -32440,7 +32485,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32477,8 +32522,8 @@ static const uint16_t ts_small_parse_table[] = { [30270] = 11, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(726), 1, @@ -32489,7 +32534,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(481), 2, anon_sym_LT, @@ -32524,15 +32569,15 @@ static const uint16_t ts_small_parse_table[] = { [30328] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(730), 1, anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(485), 3, anon_sym_LT, @@ -32568,8 +32613,8 @@ static const uint16_t ts_small_parse_table[] = { [30380] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -32588,7 +32633,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(805), 1, anon_sym_LBRACE, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32621,8 +32666,8 @@ static const uint16_t ts_small_parse_table[] = { [30450] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32641,7 +32686,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32674,8 +32719,8 @@ static const uint16_t ts_small_parse_table[] = { [30520] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -32692,7 +32737,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32726,8 +32771,8 @@ static const uint16_t ts_small_parse_table[] = { [30588] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -32746,7 +32791,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(808), 1, anon_sym_LBRACE, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32779,8 +32824,8 @@ static const uint16_t ts_small_parse_table[] = { [30658] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32799,7 +32844,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32832,8 +32877,8 @@ static const uint16_t ts_small_parse_table[] = { [30728] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -32850,7 +32895,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32884,8 +32929,8 @@ static const uint16_t ts_small_parse_table[] = { [30796] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -32904,7 +32949,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(811), 1, anon_sym_LBRACE, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32937,8 +32982,8 @@ static const uint16_t ts_small_parse_table[] = { [30866] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -32957,7 +33002,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -32990,8 +33035,8 @@ static const uint16_t ts_small_parse_table[] = { [30936] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -33010,7 +33055,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33043,8 +33088,8 @@ static const uint16_t ts_small_parse_table[] = { [31006] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -33063,7 +33108,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(814), 1, anon_sym_LBRACE, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33096,8 +33141,8 @@ static const uint16_t ts_small_parse_table[] = { [31076] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -33116,7 +33161,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33149,8 +33194,8 @@ static const uint16_t ts_small_parse_table[] = { [31146] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(716), 1, @@ -33169,7 +33214,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(817), 1, anon_sym_LBRACE, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33202,8 +33247,8 @@ static const uint16_t ts_small_parse_table[] = { [31216] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -33222,7 +33267,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33255,8 +33300,8 @@ static const uint16_t ts_small_parse_table[] = { [31286] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(708), 1, @@ -33275,7 +33320,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33308,13 +33353,13 @@ static const uint16_t ts_small_parse_table[] = { [31356] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(419), 4, + ACTIONS(419), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(421), 30, + ACTIONS(421), 31, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -33347,8 +33392,8 @@ static const uint16_t ts_small_parse_table[] = { [31398] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(706), 1, anon_sym_DOT, ACTIONS(720), 1, @@ -33361,7 +33406,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK2, ACTIONS(732), 1, sym__call_open_gap, - STATE(1654), 1, + STATE(1647), 1, sym__call_type_arguments, ACTIONS(712), 2, anon_sym_STAR, @@ -33397,13 +33442,13 @@ static const uint16_t ts_small_parse_table[] = { [31462] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(648), 4, + ACTIONS(648), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(651), 29, + ACTIONS(651), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33435,13 +33480,13 @@ static const uint16_t ts_small_parse_table[] = { [31503] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(572), 4, + ACTIONS(572), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(574), 29, + ACTIONS(574), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33473,13 +33518,13 @@ static const uint16_t ts_small_parse_table[] = { [31544] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(576), 4, + ACTIONS(576), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(579), 29, + ACTIONS(579), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33511,13 +33556,13 @@ static const uint16_t ts_small_parse_table[] = { [31585] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(582), 4, + ACTIONS(582), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(584), 29, + ACTIONS(584), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33549,13 +33594,13 @@ static const uint16_t ts_small_parse_table[] = { [31626] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(586), 4, + ACTIONS(586), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(588), 29, + ACTIONS(588), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33587,13 +33632,13 @@ static const uint16_t ts_small_parse_table[] = { [31667] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(590), 4, + ACTIONS(590), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(593), 29, + ACTIONS(593), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33625,13 +33670,13 @@ static const uint16_t ts_small_parse_table[] = { [31708] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(596), 4, + ACTIONS(596), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(598), 29, + ACTIONS(598), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33663,13 +33708,13 @@ static const uint16_t ts_small_parse_table[] = { [31749] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(556), 4, + ACTIONS(556), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(558), 29, + ACTIONS(558), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33701,13 +33746,13 @@ static const uint16_t ts_small_parse_table[] = { [31790] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(604), 4, + ACTIONS(604), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(606), 29, + ACTIONS(606), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33739,13 +33784,13 @@ static const uint16_t ts_small_parse_table[] = { [31831] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(608), 4, + ACTIONS(608), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(610), 29, + ACTIONS(610), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33777,13 +33822,13 @@ static const uint16_t ts_small_parse_table[] = { [31872] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(612), 4, + ACTIONS(612), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(614), 29, + ACTIONS(614), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33815,13 +33860,13 @@ static const uint16_t ts_small_parse_table[] = { [31913] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(568), 4, + ACTIONS(568), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(570), 29, + ACTIONS(570), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33853,13 +33898,13 @@ static const uint16_t ts_small_parse_table[] = { [31954] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(620), 4, + ACTIONS(620), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(622), 29, + ACTIONS(622), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33891,13 +33936,13 @@ static const uint16_t ts_small_parse_table[] = { [31995] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(600), 4, + ACTIONS(600), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(602), 29, + ACTIONS(602), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33929,13 +33974,13 @@ static const uint16_t ts_small_parse_table[] = { [32036] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(628), 4, + ACTIONS(628), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(630), 29, + ACTIONS(630), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33967,13 +34012,13 @@ static const uint16_t ts_small_parse_table[] = { [32077] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(632), 4, + ACTIONS(632), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(634), 29, + ACTIONS(634), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34005,13 +34050,13 @@ static const uint16_t ts_small_parse_table[] = { [32118] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(624), 4, + ACTIONS(624), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(626), 29, + ACTIONS(626), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34043,13 +34088,13 @@ static const uint16_t ts_small_parse_table[] = { [32159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(640), 4, + ACTIONS(640), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(642), 29, + ACTIONS(642), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34081,13 +34126,13 @@ static const uint16_t ts_small_parse_table[] = { [32200] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(548), 4, + ACTIONS(548), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(550), 29, + ACTIONS(550), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34119,13 +34164,13 @@ static const uint16_t ts_small_parse_table[] = { [32241] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(682), 4, + ACTIONS(682), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(684), 29, + ACTIONS(684), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34157,13 +34202,13 @@ static const uint16_t ts_small_parse_table[] = { [32282] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(644), 4, + ACTIONS(644), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(646), 29, + ACTIONS(646), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34195,13 +34240,13 @@ static const uint16_t ts_small_parse_table[] = { [32323] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(654), 4, + ACTIONS(654), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(656), 29, + ACTIONS(656), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34233,13 +34278,13 @@ static const uint16_t ts_small_parse_table[] = { [32364] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(658), 4, + ACTIONS(658), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(660), 29, + ACTIONS(660), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34271,13 +34316,13 @@ static const uint16_t ts_small_parse_table[] = { [32405] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(636), 4, + ACTIONS(636), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(638), 29, + ACTIONS(638), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34309,13 +34354,13 @@ static const uint16_t ts_small_parse_table[] = { [32446] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(666), 4, + ACTIONS(666), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(668), 29, + ACTIONS(668), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34347,13 +34392,13 @@ static const uint16_t ts_small_parse_table[] = { [32487] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(403), 4, + ACTIONS(403), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(405), 29, + ACTIONS(405), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34385,13 +34430,13 @@ static const uint16_t ts_small_parse_table[] = { [32528] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(674), 4, + ACTIONS(674), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(676), 29, + ACTIONS(676), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34423,13 +34468,13 @@ static const uint16_t ts_small_parse_table[] = { [32569] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(678), 4, + ACTIONS(678), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(680), 29, + ACTIONS(680), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34461,13 +34506,13 @@ static const uint16_t ts_small_parse_table[] = { [32610] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(686), 4, + ACTIONS(686), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(688), 29, + ACTIONS(688), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34499,13 +34544,13 @@ static const uint16_t ts_small_parse_table[] = { [32651] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(690), 4, + ACTIONS(690), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(692), 29, + ACTIONS(692), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34537,13 +34582,13 @@ static const uint16_t ts_small_parse_table[] = { [32692] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(694), 4, + ACTIONS(694), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(696), 29, + ACTIONS(696), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34575,13 +34620,13 @@ static const uint16_t ts_small_parse_table[] = { [32733] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(564), 4, + ACTIONS(564), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(566), 29, + ACTIONS(566), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34613,13 +34658,13 @@ static const uint16_t ts_small_parse_table[] = { [32774] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(662), 4, + ACTIONS(662), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(664), 29, + ACTIONS(664), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34651,13 +34696,13 @@ static const uint16_t ts_small_parse_table[] = { [32815] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(552), 4, + ACTIONS(552), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(554), 29, + ACTIONS(554), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34689,13 +34734,13 @@ static const uint16_t ts_small_parse_table[] = { [32856] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(670), 4, + ACTIONS(670), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(672), 29, + ACTIONS(672), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34727,13 +34772,13 @@ static const uint16_t ts_small_parse_table[] = { [32897] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(560), 4, + ACTIONS(560), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(562), 29, + ACTIONS(562), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34765,13 +34810,13 @@ static const uint16_t ts_small_parse_table[] = { [32938] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(616), 4, + ACTIONS(616), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(618), 29, + ACTIONS(618), 30, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -34818,12 +34863,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(824), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -34870,12 +34915,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(831), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -35012,7 +35057,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(298), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(841), 1, anon_sym_COLON_COLON, ACTIONS(843), 1, @@ -35023,15 +35068,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, STATE(439), 1, aux_sym_qualified_path_repeat1, - STATE(1485), 1, + STATE(1598), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 17, + ACTIONS(405), 18, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -35074,7 +35119,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_signature, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35119,7 +35164,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35164,7 +35209,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35209,7 +35254,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35254,7 +35299,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35280,19 +35325,19 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(409), 1, anon_sym_LBRACE, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(881), 1, anon_sym_COLON, STATE(232), 1, aux_sym_qualified_path_repeat1, - STATE(1690), 1, + STATE(1683), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 17, + ACTIONS(405), 18, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_STAR, anon_sym_COMMA, @@ -35313,23 +35358,23 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(298), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(841), 1, anon_sym_COLON_COLON, ACTIONS(843), 1, anon_sym_LBRACE, STATE(439), 1, aux_sym_qualified_path_repeat1, - STATE(1485), 1, + STATE(1598), 1, sym_type_arguments, - ACTIONS(403), 4, + ACTIONS(403), 3, anon_sym_COLON, - anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 17, + ACTIONS(405), 18, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -35353,23 +35398,23 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(409), 1, anon_sym_LBRACE, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(883), 1, anon_sym_RBRACE, ACTIONS(886), 1, anon_sym_COMMA, STATE(232), 1, aux_sym_qualified_path_repeat1, - STATE(1218), 1, + STATE(1162), 1, aux_sym_field_pattern_repeat1, - STATE(1690), 1, + STATE(1683), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 15, + ACTIONS(405), 16, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_STAR, anon_sym_QMARK, @@ -35388,7 +35433,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(298), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(841), 1, anon_sym_COLON_COLON, ACTIONS(843), 1, @@ -35397,15 +35442,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, STATE(439), 1, aux_sym_qualified_path_repeat1, - STATE(1485), 1, + STATE(1598), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 17, + ACTIONS(405), 18, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -35448,7 +35493,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35493,7 +35538,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35538,7 +35583,7 @@ static const uint16_t ts_small_parse_table[] = { sym__doc_comment_line, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(894), 2, anon_sym_let, @@ -35583,7 +35628,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35628,7 +35673,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35673,7 +35718,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35718,7 +35763,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35763,7 +35808,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35808,7 +35853,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35853,7 +35898,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35898,7 +35943,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35943,7 +35988,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -35988,7 +36033,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36033,7 +36078,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36078,7 +36123,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36123,7 +36168,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36168,7 +36213,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36213,7 +36258,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36258,7 +36303,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36303,7 +36348,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36348,7 +36393,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36393,7 +36438,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36438,7 +36483,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36483,7 +36528,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36528,7 +36573,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36573,7 +36618,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36618,7 +36663,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36663,7 +36708,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(812), 1, + STATE(804), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, @@ -36722,15 +36767,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(438), 1, aux_sym_qualified_path_repeat1, - ACTIONS(419), 5, + ACTIONS(419), 4, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(421), 18, + ACTIONS(421), 19, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -36754,15 +36799,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(438), 1, aux_sym_qualified_path_repeat1, - ACTIONS(426), 5, + ACTIONS(426), 4, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(428), 18, + ACTIONS(428), 19, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -36782,15 +36827,15 @@ static const uint16_t ts_small_parse_table[] = { [35632] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(419), 5, + ACTIONS(419), 4, anon_sym_COLON, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(421), 19, + ACTIONS(421), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -36828,16 +36873,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(988), 1, anon_sym_COMMA, ACTIONS(990), 1, anon_sym_RPAREN, - STATE(1157), 1, + STATE(1202), 1, aux_sym_argument_list_repeat1, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -36856,15 +36901,15 @@ static const uint16_t ts_small_parse_table[] = { [35728] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, anon_sym_LBRACK2, ACTIONS(996), 1, sym__call_open_gap, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(469), 3, anon_sym_LT, @@ -36890,8 +36935,8 @@ static const uint16_t ts_small_parse_table[] = { [35770] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -36910,7 +36955,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -36933,8 +36978,8 @@ static const uint16_t ts_small_parse_table[] = { [35830] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -36953,7 +36998,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -36978,8 +37023,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37002,7 +37047,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1023), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37021,8 +37066,8 @@ static const uint16_t ts_small_parse_table[] = { [35954] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37039,7 +37084,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37063,8 +37108,8 @@ static const uint16_t ts_small_parse_table[] = { [36012] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37083,7 +37128,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37106,8 +37151,8 @@ static const uint16_t ts_small_parse_table[] = { [36072] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37126,7 +37171,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37149,8 +37194,8 @@ static const uint16_t ts_small_parse_table[] = { [36132] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37169,7 +37214,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37193,18 +37238,18 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(298), 1, sym_line_comment, ACTIONS(412), 1, - anon_sym_LT2, + anon_sym_LT, ACTIONS(1025), 1, anon_sym_LBRACE, - STATE(1485), 1, + STATE(1598), 1, sym_type_arguments, - ACTIONS(403), 3, - anon_sym_LT, + ACTIONS(403), 2, anon_sym_GT, anon_sym_SLASH, - ACTIONS(405), 18, + ACTIONS(405), 19, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_RBRACE, anon_sym_STAR, @@ -37224,8 +37269,8 @@ static const uint16_t ts_small_parse_table[] = { [36230] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37244,7 +37289,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37267,8 +37312,8 @@ static const uint16_t ts_small_parse_table[] = { [36290] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37287,7 +37332,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1028), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37327,10 +37372,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37370,10 +37415,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37396,8 +37441,8 @@ static const uint16_t ts_small_parse_table[] = { [36470] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37416,7 +37461,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37439,8 +37484,8 @@ static const uint16_t ts_small_parse_table[] = { [36530] = 16, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37457,7 +37502,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37498,16 +37543,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(988), 1, anon_sym_COMMA, ACTIONS(1035), 1, anon_sym_RBRACK, - STATE(1217), 1, + STATE(1170), 1, aux_sym_argument_list_repeat1, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37526,8 +37571,8 @@ static const uint16_t ts_small_parse_table[] = { [36652] = 14, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37540,7 +37585,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37566,8 +37611,8 @@ static const uint16_t ts_small_parse_table[] = { [36706] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37578,7 +37623,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37605,8 +37650,8 @@ static const uint16_t ts_small_parse_table[] = { [36758] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37625,7 +37670,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1037), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37648,8 +37693,8 @@ static const uint16_t ts_small_parse_table[] = { [36818] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37668,7 +37713,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1040), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37693,8 +37738,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37717,7 +37762,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1023), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37753,16 +37798,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(988), 1, anon_sym_COMMA, ACTIONS(1043), 1, anon_sym_RBRACK, - STATE(1138), 1, + STATE(1132), 1, aux_sym_argument_list_repeat1, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -37781,8 +37826,8 @@ static const uint16_t ts_small_parse_table[] = { [37006] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37801,7 +37846,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37824,8 +37869,8 @@ static const uint16_t ts_small_parse_table[] = { [37066] = 11, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37836,7 +37881,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(481), 2, anon_sym_LT, @@ -37861,15 +37906,15 @@ static const uint16_t ts_small_parse_table[] = { [37114] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, anon_sym_LBRACK2, ACTIONS(996), 1, sym__call_open_gap, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(485), 3, anon_sym_LT, @@ -37897,8 +37942,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37921,7 +37966,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1023), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -37940,8 +37985,8 @@ static const uint16_t ts_small_parse_table[] = { [37220] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -37960,7 +38005,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1045), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -38000,16 +38045,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(988), 1, anon_sym_COMMA, ACTIONS(1048), 1, anon_sym_RBRACK, - STATE(1133), 1, + STATE(1239), 1, aux_sym_argument_list_repeat1, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38028,8 +38073,8 @@ static const uint16_t ts_small_parse_table[] = { [37344] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38048,7 +38093,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -38071,8 +38116,8 @@ static const uint16_t ts_small_parse_table[] = { [37404] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38081,7 +38126,7 @@ static const uint16_t ts_small_parse_table[] = { sym__call_open_gap, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(481), 3, anon_sym_LT, @@ -38106,8 +38151,8 @@ static const uint16_t ts_small_parse_table[] = { [37448] = 12, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38118,7 +38163,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, ACTIONS(1017), 1, anon_sym_PIPE_GT, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(481), 2, anon_sym_LT, @@ -38161,10 +38206,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38187,14 +38232,14 @@ static const uint16_t ts_small_parse_table[] = { [37558] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(674), 4, + ACTIONS(674), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(676), 19, + ACTIONS(676), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38215,14 +38260,14 @@ static const uint16_t ts_small_parse_table[] = { [37589] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(654), 4, + ACTIONS(654), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(656), 19, + ACTIONS(656), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38243,14 +38288,14 @@ static const uint16_t ts_small_parse_table[] = { [37620] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(658), 4, + ACTIONS(658), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(660), 19, + ACTIONS(660), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38288,10 +38333,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38313,14 +38358,14 @@ static const uint16_t ts_small_parse_table[] = { [37710] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(576), 4, + ACTIONS(576), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(579), 19, + ACTIONS(579), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38341,14 +38386,14 @@ static const uint16_t ts_small_parse_table[] = { [37741] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(582), 4, + ACTIONS(582), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(584), 19, + ACTIONS(584), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38386,10 +38431,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38411,8 +38456,8 @@ static const uint16_t ts_small_parse_table[] = { [37831] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38435,7 +38480,7 @@ static const uint16_t ts_small_parse_table[] = { sym__statement_break, ACTIONS(1056), 1, anon_sym_RBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -38468,9 +38513,9 @@ static const uint16_t ts_small_parse_table[] = { sym_float, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -38478,7 +38523,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(553), 2, + STATE(555), 2, sym_match_arm, aux_sym_match_expression_repeat1, ACTIONS(1066), 4, @@ -38486,7 +38531,7 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, @@ -38494,14 +38539,14 @@ static const uint16_t ts_small_parse_table[] = { [37947] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(596), 4, + ACTIONS(596), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(598), 19, + ACTIONS(598), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38522,14 +38567,14 @@ static const uint16_t ts_small_parse_table[] = { [37978] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(670), 4, + ACTIONS(670), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(672), 19, + ACTIONS(672), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38550,14 +38595,14 @@ static const uint16_t ts_small_parse_table[] = { [38009] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(640), 4, + ACTIONS(640), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(642), 19, + ACTIONS(642), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38578,14 +38623,14 @@ static const uint16_t ts_small_parse_table[] = { [38040] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(604), 4, + ACTIONS(604), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(606), 19, + ACTIONS(606), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38608,8 +38653,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38630,7 +38675,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(1023), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -38649,14 +38694,14 @@ static const uint16_t ts_small_parse_table[] = { [38132] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(636), 4, + ACTIONS(636), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(638), 19, + ACTIONS(638), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38677,14 +38722,14 @@ static const uint16_t ts_small_parse_table[] = { [38163] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(682), 4, + ACTIONS(682), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(684), 19, + ACTIONS(684), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38705,14 +38750,14 @@ static const uint16_t ts_small_parse_table[] = { [38194] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(568), 4, + ACTIONS(568), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(570), 19, + ACTIONS(570), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38733,14 +38778,14 @@ static const uint16_t ts_small_parse_table[] = { [38225] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(608), 4, + ACTIONS(608), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(610), 19, + ACTIONS(610), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38778,10 +38823,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38803,14 +38848,14 @@ static const uint16_t ts_small_parse_table[] = { [38315] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(620), 4, + ACTIONS(620), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(622), 19, + ACTIONS(622), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38831,14 +38876,14 @@ static const uint16_t ts_small_parse_table[] = { [38346] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(612), 4, + ACTIONS(612), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(614), 19, + ACTIONS(614), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38861,8 +38906,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -38883,7 +38928,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(1023), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -38919,10 +38964,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -38944,14 +38989,14 @@ static const uint16_t ts_small_parse_table[] = { [38497] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(628), 4, + ACTIONS(628), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(630), 19, + ACTIONS(630), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -38989,10 +39034,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -39014,14 +39059,14 @@ static const uint16_t ts_small_parse_table[] = { [38587] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(586), 4, + ACTIONS(586), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(588), 19, + ACTIONS(588), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39042,14 +39087,14 @@ static const uint16_t ts_small_parse_table[] = { [38618] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(690), 4, + ACTIONS(690), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(692), 19, + ACTIONS(692), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39070,14 +39115,14 @@ static const uint16_t ts_small_parse_table[] = { [38649] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(552), 4, + ACTIONS(552), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(554), 19, + ACTIONS(554), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39098,14 +39143,14 @@ static const uint16_t ts_small_parse_table[] = { [38680] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(644), 4, + ACTIONS(644), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(646), 19, + ACTIONS(646), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39126,14 +39171,14 @@ static const uint16_t ts_small_parse_table[] = { [38711] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(560), 4, + ACTIONS(560), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(562), 19, + ACTIONS(562), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39154,14 +39199,14 @@ static const uint16_t ts_small_parse_table[] = { [38742] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(632), 4, + ACTIONS(632), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(634), 19, + ACTIONS(634), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39182,14 +39227,14 @@ static const uint16_t ts_small_parse_table[] = { [38773] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(548), 4, + ACTIONS(548), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(550), 19, + ACTIONS(550), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39210,14 +39255,14 @@ static const uint16_t ts_small_parse_table[] = { [38804] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(600), 4, + ACTIONS(600), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(602), 19, + ACTIONS(602), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39238,8 +39283,8 @@ static const uint16_t ts_small_parse_table[] = { [38835] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -39262,7 +39307,7 @@ static const uint16_t ts_small_parse_table[] = { sym__statement_break, ACTIONS(1082), 1, anon_sym_RBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -39295,9 +39340,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -39313,7 +39358,7 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, @@ -39321,14 +39366,14 @@ static const uint16_t ts_small_parse_table[] = { [38951] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(666), 4, + ACTIONS(666), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(668), 19, + ACTIONS(668), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39349,14 +39394,14 @@ static const uint16_t ts_small_parse_table[] = { [38982] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(616), 4, + ACTIONS(616), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(618), 19, + ACTIONS(618), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39377,14 +39422,14 @@ static const uint16_t ts_small_parse_table[] = { [39013] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(694), 4, + ACTIONS(694), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(696), 19, + ACTIONS(696), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39405,14 +39450,14 @@ static const uint16_t ts_small_parse_table[] = { [39044] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(678), 4, + ACTIONS(678), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(680), 19, + ACTIONS(680), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39433,8 +39478,8 @@ static const uint16_t ts_small_parse_table[] = { [39075] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -39457,7 +39502,7 @@ static const uint16_t ts_small_parse_table[] = { sym__statement_break, ACTIONS(1086), 1, anon_sym_RBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -39476,14 +39521,14 @@ static const uint16_t ts_small_parse_table[] = { [39136] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(590), 4, + ACTIONS(590), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(593), 19, + ACTIONS(593), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39504,8 +39549,8 @@ static const uint16_t ts_small_parse_table[] = { [39167] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -39528,7 +39573,7 @@ static const uint16_t ts_small_parse_table[] = { sym__statement_break, ACTIONS(1088), 1, anon_sym_RBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -39547,14 +39592,14 @@ static const uint16_t ts_small_parse_table[] = { [39228] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(572), 4, + ACTIONS(572), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(574), 19, + ACTIONS(574), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39575,14 +39620,14 @@ static const uint16_t ts_small_parse_table[] = { [39259] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(556), 4, + ACTIONS(556), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(558), 19, + ACTIONS(558), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39647,9 +39692,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, - STATE(1736), 1, + STATE(1729), 1, sym_field_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -39657,7 +39702,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(558), 2, + STATE(560), 2, sym_match_arm, aux_sym_match_expression_repeat1, ACTIONS(1066), 4, @@ -39665,7 +39710,7 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, @@ -39673,14 +39718,14 @@ static const uint16_t ts_small_parse_table[] = { [39380] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(648), 4, + ACTIONS(648), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(651), 19, + ACTIONS(651), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39701,14 +39746,14 @@ static const uint16_t ts_small_parse_table[] = { [39411] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(686), 4, + ACTIONS(686), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(688), 19, + ACTIONS(688), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39729,8 +39774,8 @@ static const uint16_t ts_small_parse_table[] = { [39442] = 18, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -39753,7 +39798,7 @@ static const uint16_t ts_small_parse_table[] = { sym__statement_break, ACTIONS(1092), 1, anon_sym_RBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -39772,14 +39817,14 @@ static const uint16_t ts_small_parse_table[] = { [39503] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(624), 4, + ACTIONS(624), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(626), 19, + ACTIONS(626), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39800,14 +39845,14 @@ static const uint16_t ts_small_parse_table[] = { [39534] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(662), 4, + ACTIONS(662), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(664), 19, + ACTIONS(664), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39828,14 +39873,14 @@ static const uint16_t ts_small_parse_table[] = { [39565] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(403), 4, + ACTIONS(403), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(405), 19, + ACTIONS(405), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39856,14 +39901,14 @@ static const uint16_t ts_small_parse_table[] = { [39596] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(564), 4, + ACTIONS(564), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(566), 19, + ACTIONS(566), 20, sym__call_open_gap, sym__statement_break, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -39884,9 +39929,50 @@ static const uint16_t ts_small_parse_table[] = { [39627] = 17, ACTIONS(298), 1, sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(803), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1094), 1, + anon_sym_RBRACE, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [39685] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(794), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -39906,7 +39992,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -39922,49 +40008,90 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39685] = 14, + [39743] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1094), 1, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1096), 1, + anon_sym_RBRACK, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [39801] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1098), 1, sym_identifier, - ACTIONS(1097), 1, + ACTIONS(1101), 1, anon_sym_LBRACE, - ACTIONS(1100), 1, + ACTIONS(1104), 1, anon_sym_RBRACE, - ACTIONS(1102), 1, + ACTIONS(1106), 1, anon_sym_LPAREN, - ACTIONS(1108), 1, + ACTIONS(1112), 1, anon_sym_LBRACK, - ACTIONS(1117), 1, + ACTIONS(1121), 1, sym_float, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, - ACTIONS(1111), 2, + ACTIONS(1115), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1114), 2, + ACTIONS(1118), 2, anon_sym_true, anon_sym_false, - STATE(528), 2, + STATE(530), 2, sym_match_arm, aux_sym_match_expression_repeat1, - ACTIONS(1105), 4, + ACTIONS(1109), 4, anon_sym__, sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [39737] = 17, + [39853] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(796), 1, sym__statement_break, ACTIONS(992), 1, @@ -39985,7 +40112,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40001,11 +40128,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39795] = 17, + [39911] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(764), 1, sym__statement_break, ACTIONS(992), 1, @@ -40026,7 +40153,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40042,11 +40169,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39853] = 17, + [39969] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(742), 1, sym__statement_break, ACTIONS(992), 1, @@ -40067,7 +40194,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40083,11 +40210,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39911] = 17, + [40027] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(766), 1, sym__statement_break, ACTIONS(992), 1, @@ -40108,7 +40235,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40124,11 +40251,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [39969] = 17, + [40085] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(756), 1, sym__statement_break, ACTIONS(992), 1, @@ -40149,7 +40276,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40165,19 +40292,19 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40027] = 4, + [40143] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1120), 2, + ACTIONS(1124), 2, anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(644), 4, + ACTIONS(644), 3, anon_sym_LT, anon_sym_GT, anon_sym_SLASH, - anon_sym_LT2, - ACTIONS(646), 16, + ACTIONS(646), 17, sym__call_open_gap, + sym__type_application_ahead, anon_sym_DOT, anon_sym_LBRACE, anon_sym_STAR, @@ -40193,11 +40320,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, - [40059] = 17, + [40175] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -40216,9 +40343,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(1122), 1, + ACTIONS(1126), 1, sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40234,11 +40361,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40117] = 17, + [40233] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(768), 1, sym__statement_break, ACTIONS(992), 1, @@ -40259,7 +40386,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40275,11 +40402,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40175] = 17, + [40291] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(770), 1, sym__statement_break, ACTIONS(992), 1, @@ -40300,7 +40427,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40316,11 +40443,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40233] = 17, + [40349] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(754), 1, sym__statement_break, ACTIONS(992), 1, @@ -40341,7 +40468,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40357,7 +40484,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40291] = 17, + [40407] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40377,12 +40504,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1124), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1128), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40398,11 +40525,52 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40349] = 17, + [40465] = 17, ACTIONS(298), 1, sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1130), 1, + anon_sym_RPAREN, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [40523] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(772), 1, sym__statement_break, ACTIONS(992), 1, @@ -40423,7 +40591,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40439,7 +40607,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40407] = 17, + [40581] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40459,12 +40627,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(1021), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40480,11 +40648,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40465] = 17, + [40639] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(758), 1, sym__statement_break, ACTIONS(992), 1, @@ -40505,7 +40673,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40521,52 +40689,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40523] = 17, + [40697] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1126), 1, - anon_sym_RPAREN, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [40581] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + sym__type_application_ahead, ACTIONS(774), 1, sym__statement_break, ACTIONS(992), 1, @@ -40587,7 +40714,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -40603,7 +40730,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40639] = 14, + [40755] = 14, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -40614,13 +40741,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1130), 1, + ACTIONS(1134), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -40628,7 +40755,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(598), 2, + STATE(603), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -40636,12 +40763,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [40691] = 17, + [40807] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40661,12 +40788,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1132), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1136), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40682,7 +40809,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40749] = 17, + [40865] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40702,12 +40829,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1134), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1138), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40723,7 +40850,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40807] = 17, + [40923] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40743,12 +40870,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1136), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1140), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40764,7 +40891,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40865] = 17, + [40981] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40784,12 +40911,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1138), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1142), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40805,7 +40932,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40923] = 17, + [41039] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40825,12 +40952,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1140), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1144), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40846,7 +40973,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [40981] = 17, + [41097] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40866,12 +40993,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1142), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1146), 1, anon_sym_RBRACK, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -40887,7 +41014,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41039] = 14, + [41155] = 14, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -40898,13 +41025,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1144), 1, + ACTIONS(1148), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -40912,7 +41039,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(598), 2, + STATE(603), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -40920,12 +41047,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [41091] = 14, + [41207] = 14, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -40936,13 +41063,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1146), 1, + ACTIONS(1150), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -40950,7 +41077,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(528), 2, + STATE(530), 2, sym_match_arm, aux_sym_match_expression_repeat1, ACTIONS(1066), 4, @@ -40958,12 +41085,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [41143] = 17, + [41259] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -40983,12 +41110,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1148), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1152), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41004,7 +41131,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41201] = 17, + [41317] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41024,12 +41151,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1150), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1154), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41045,7 +41172,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41259] = 17, + [41375] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41065,12 +41192,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1152), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1156), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41086,11 +41213,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41317] = 17, + [41433] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(776), 1, sym__statement_break, ACTIONS(992), 1, @@ -41111,7 +41238,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41127,7 +41254,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41375] = 14, + [41491] = 14, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -41138,13 +41265,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1154), 1, + ACTIONS(1158), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -41152,7 +41279,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(528), 2, + STATE(530), 2, sym_match_arm, aux_sym_match_expression_repeat1, ACTIONS(1066), 4, @@ -41160,12 +41287,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [41427] = 15, + [41543] = 15, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -41186,16 +41313,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, ACTIONS(871), 1, anon_sym_signature, - ACTIONS(1156), 1, + ACTIONS(1160), 1, anon_sym_opaque, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(839), 1, + STATE(832), 1, sym_doc_comment, ACTIONS(853), 2, anon_sym_let, anon_sym_mut, - STATE(714), 8, + STATE(712), 8, sym_let_declaration, sym_function_declaration, sym_extern_declaration, @@ -41204,11 +41331,52 @@ static const uint16_t ts_small_parse_table[] = { sym_module_declaration, sym__module_declaration, sym_signature_declaration, - [41481] = 17, + [41597] = 17, ACTIONS(298), 1, sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1162), 1, + anon_sym_COLON, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [41655] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(710), 1, sym__statement_break, ACTIONS(992), 1, @@ -41229,7 +41397,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41245,11 +41413,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41539] = 17, + [41713] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(801), 1, sym__statement_break, ACTIONS(992), 1, @@ -41270,7 +41438,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41286,7 +41454,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41597] = 17, + [41771] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41306,12 +41474,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1158), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1164), 1, anon_sym_RBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41327,7 +41495,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41655] = 17, + [41829] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41347,12 +41515,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1160), 1, - anon_sym_COLON, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1166), 1, + anon_sym_RBRACE, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41368,7 +41536,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41713] = 17, + [41887] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41388,12 +41556,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1162), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1168), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41409,13 +41577,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41771] = 17, + [41945] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(752), 1, - sym__statement_break, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -41434,7 +41600,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + ACTIONS(1023), 1, + sym__statement_break, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41450,7 +41618,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41829] = 17, + [42003] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41470,53 +41638,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1164), 1, - anon_sym_RBRACE, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [41887] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1166), 1, + sym__type_application_ahead, + ACTIONS(1170), 1, anon_sym_COMMA, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41532,7 +41659,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [41945] = 17, + [42061] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41552,12 +41679,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1168), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1172), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41573,12 +41700,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42003] = 17, + [42119] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(734), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(752), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -41598,7 +41725,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41614,11 +41741,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42061] = 17, + [42177] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(740), 1, sym__statement_break, ACTIONS(992), 1, @@ -41639,7 +41766,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -41655,7 +41782,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42119] = 17, + [42235] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41675,12 +41802,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1170), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1174), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41696,48 +41823,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42177] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(780), 1, - sym__statement_break, - ACTIONS(992), 1, - anon_sym_DOT, - ACTIONS(994), 1, - anon_sym_LBRACK2, - ACTIONS(996), 1, - sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_QMARK, - ACTIONS(1007), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1009), 1, - anon_sym_AMP_AMP, - ACTIONS(1015), 1, - anon_sym_SLASH, - ACTIONS(1017), 1, - anon_sym_PIPE_GT, - ACTIONS(1019), 1, - anon_sym_LBRACE, - STATE(1718), 1, - sym__call_type_arguments, - ACTIONS(1001), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1003), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1013), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1011), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [42235] = 17, + [42293] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -41757,12 +41843,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1172), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1176), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41778,47 +41864,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [42293] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(782), 1, - sym__statement_break, - ACTIONS(992), 1, - anon_sym_DOT, - ACTIONS(994), 1, - anon_sym_LBRACK2, - ACTIONS(996), 1, - sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_QMARK, - ACTIONS(1007), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1009), 1, - anon_sym_AMP_AMP, - ACTIONS(1015), 1, - anon_sym_SLASH, - ACTIONS(1017), 1, - anon_sym_PIPE_GT, - ACTIONS(1019), 1, - anon_sym_LBRACE, - STATE(1718), 1, - sym__call_type_arguments, - ACTIONS(1001), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1003), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1013), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1011), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, [42351] = 14, ACTIONS(298), 1, sym_line_comment, @@ -41830,13 +41875,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1174), 1, + ACTIONS(1178), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -41844,7 +41889,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(598), 2, + STATE(603), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -41852,7 +41897,7 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, @@ -41877,12 +41922,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1176), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1180), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41918,12 +41963,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1178), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1182), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41959,12 +42004,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1180), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1184), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -41983,9 +42028,9 @@ static const uint16_t ts_small_parse_table[] = { [42577] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(784), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(780), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42005,7 +42050,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42041,12 +42086,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1182), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1186), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42082,12 +42127,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1184), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1188), 1, anon_sym_RBRACK, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42106,9 +42151,9 @@ static const uint16_t ts_small_parse_table[] = { [42751] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(778), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(782), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42128,7 +42173,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42155,13 +42200,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1186), 1, + ACTIONS(1190), 1, anon_sym_RBRACE, STATE(1282), 1, sym_qualified_path, - STATE(1666), 1, + STATE(1682), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -42169,7 +42214,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(528), 2, + STATE(530), 2, sym_match_arm, aux_sym_match_expression_repeat1, ACTIONS(1066), 4, @@ -42177,7 +42222,7 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, @@ -42202,12 +42247,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1188), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1192), 1, anon_sym_RPAREN, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42224,47 +42269,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_EQ, anon_sym_GT_EQ, [42919] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(786), 1, - sym__statement_break, - ACTIONS(992), 1, - anon_sym_DOT, - ACTIONS(994), 1, - anon_sym_LBRACK2, - ACTIONS(996), 1, - sym__call_open_gap, - ACTIONS(1005), 1, - anon_sym_QMARK, - ACTIONS(1007), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1009), 1, - anon_sym_AMP_AMP, - ACTIONS(1015), 1, - anon_sym_SLASH, - ACTIONS(1017), 1, - anon_sym_PIPE_GT, - ACTIONS(1019), 1, - anon_sym_LBRACE, - STATE(1718), 1, - sym__call_type_arguments, - ACTIONS(1001), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1003), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1013), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1011), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [42977] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42284,12 +42288,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1190), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1194), 1, anon_sym_COLON, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42305,7 +42309,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43035] = 17, + [42977] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42325,12 +42329,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1192), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1196), 1, anon_sym_RBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42346,12 +42350,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43093] = 17, + [43035] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(760), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(784), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42371,7 +42375,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42387,12 +42391,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43151] = 17, + [43093] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(762), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(778), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42412,7 +42416,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42428,12 +42432,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43209] = 17, + [43151] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(788), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(786), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42453,7 +42457,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42469,12 +42473,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43267] = 17, + [43209] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(790), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(760), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42494,7 +42498,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42510,11 +42514,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43325] = 17, + [43267] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(820), 1, sym__statement_break, ACTIONS(992), 1, @@ -42535,7 +42539,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42551,12 +42555,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43383] = 17, + [43325] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(750), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(803), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42576,7 +42580,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42592,50 +42596,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43441] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(855), 1, - anon_sym_fn, - ACTIONS(857), 1, - anon_sym_extern, - ACTIONS(859), 1, - anon_sym_type, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(865), 1, - anon_sym_state, - ACTIONS(867), 1, - anon_sym_module, - ACTIONS(871), 1, - anon_sym_signature, - ACTIONS(1194), 1, - anon_sym_opaque, - STATE(227), 1, - aux_sym_doc_comment_repeat1, - STATE(839), 1, - sym_doc_comment, - ACTIONS(853), 2, - anon_sym_let, - anon_sym_mut, - STATE(758), 8, - sym_let_declaration, - sym_function_declaration, - sym_extern_declaration, - sym_type_declaration, - sym_effect_declaration, - sym_module_declaration, - sym__module_declaration, - sym_signature_declaration, - [43495] = 17, + [43383] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(762), 1, + sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -42654,9 +42621,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(1196), 1, - sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42672,12 +42637,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43553] = 17, + [43441] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(736), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(788), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42697,7 +42662,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42713,12 +42678,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43611] = 17, + [43499] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(738), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(790), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42738,7 +42703,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42754,91 +42719,53 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43669] = 14, + [43557] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1198), 1, - sym_identifier, - ACTIONS(1201), 1, - anon_sym_LBRACE, - ACTIONS(1204), 1, - anon_sym_RBRACE, - ACTIONS(1206), 1, - anon_sym_LPAREN, - ACTIONS(1212), 1, - anon_sym_LBRACK, - ACTIONS(1221), 1, - sym_float, - STATE(1282), 1, - sym_qualified_path, - STATE(1470), 1, - sym_pattern, - ACTIONS(1215), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1218), 2, - anon_sym_true, - anon_sym_false, - STATE(598), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - ACTIONS(1209), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(1076), 4, - sym_structural_pattern, - sym_tuple_pattern, - sym_list_pattern, - sym_boolean, - [43721] = 17, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1224), 1, - anon_sym_RBRACE, - STATE(1574), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + ACTIONS(1198), 1, + sym__statement_break, + STATE(1370), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43779] = 17, + [43615] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(792), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(736), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42858,7 +42785,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42874,12 +42801,51 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43837] = 17, + [43673] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(855), 1, + anon_sym_fn, + ACTIONS(857), 1, + anon_sym_extern, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(865), 1, + anon_sym_state, + ACTIONS(867), 1, + anon_sym_module, + ACTIONS(871), 1, + anon_sym_signature, + ACTIONS(1200), 1, + anon_sym_opaque, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(832), 1, + sym_doc_comment, + ACTIONS(853), 2, + anon_sym_let, + anon_sym_mut, + STATE(758), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [43727] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(794), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(738), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -42899,7 +42865,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -42915,7 +42881,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43895] = 17, + [43785] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42935,12 +42901,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1226), 1, - anon_sym_COMMA, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1202), 1, + anon_sym_RBRACE, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42956,7 +42922,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [43953] = 17, + [43843] = 17, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -42976,12 +42942,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1228), 1, - anon_sym_RBRACE, - STATE(1574), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1204), 1, + anon_sym_COMMA, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -42997,6 +42963,85 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + [43901] = 17, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(750), 1, + sym__statement_break, + ACTIONS(992), 1, + anon_sym_DOT, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, + anon_sym_QMARK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1009), 1, + anon_sym_AMP_AMP, + ACTIONS(1015), 1, + anon_sym_SLASH, + ACTIONS(1017), 1, + anon_sym_PIPE_GT, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1370), 1, + sym__call_type_arguments, + ACTIONS(1001), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1003), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1013), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1011), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [43959] = 14, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1206), 1, + sym_identifier, + ACTIONS(1209), 1, + anon_sym_LBRACE, + ACTIONS(1212), 1, + anon_sym_RBRACE, + ACTIONS(1214), 1, + anon_sym_LPAREN, + ACTIONS(1220), 1, + anon_sym_LBRACK, + ACTIONS(1229), 1, + sym_float, + STATE(1282), 1, + sym_qualified_path, + STATE(1537), 1, + sym_pattern, + ACTIONS(1223), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1226), 2, + anon_sym_true, + anon_sym_false, + STATE(603), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + ACTIONS(1217), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(1072), 4, + sym_structural_pattern, + sym_tuple_pattern, + sym_list_pattern, + sym_boolean, [44011] = 17, ACTIONS(298), 1, sym_line_comment, @@ -43017,12 +43062,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1230), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1232), 1, anon_sym_COMMA, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43058,12 +43103,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1232), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1234), 1, anon_sym_RBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43082,8 +43127,8 @@ static const uint16_t ts_small_parse_table[] = { [44127] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(744), 1, sym__statement_break, ACTIONS(992), 1, @@ -43104,7 +43149,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -43123,8 +43168,8 @@ static const uint16_t ts_small_parse_table[] = { [44185] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(746), 1, sym__statement_break, ACTIONS(992), 1, @@ -43145,7 +43190,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -43164,9 +43209,9 @@ static const uint16_t ts_small_parse_table[] = { [44243] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(748), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(792), 1, sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, @@ -43186,7 +43231,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -43205,40 +43250,40 @@ static const uint16_t ts_small_parse_table[] = { [44301] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(748), 1, + sym__statement_break, + ACTIONS(992), 1, anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, + ACTIONS(994), 1, + anon_sym_LBRACK2, + ACTIONS(996), 1, + sym__call_open_gap, + ACTIONS(1005), 1, anon_sym_QMARK, - ACTIONS(444), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - ACTIONS(446), 1, + ACTIONS(1009), 1, anon_sym_AMP_AMP, - ACTIONS(452), 1, + ACTIONS(1015), 1, anon_sym_SLASH, - ACTIONS(454), 1, + ACTIONS(1017), 1, anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1234), 1, - anon_sym_RBRACK, - STATE(1574), 1, + ACTIONS(1019), 1, + anon_sym_LBRACE, + STATE(1370), 1, sym__call_type_arguments, - ACTIONS(438), 2, + ACTIONS(1001), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(440), 2, + ACTIONS(1003), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 2, + ACTIONS(1013), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(448), 4, + ACTIONS(1011), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -43246,8 +43291,10 @@ static const uint16_t ts_small_parse_table[] = { [44359] = 17, ACTIONS(298), 1, sym_line_comment, - ACTIONS(458), 1, - anon_sym_LT2, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(734), 1, + sym__statement_break, ACTIONS(992), 1, anon_sym_DOT, ACTIONS(994), 1, @@ -43266,9 +43313,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_GT, ACTIONS(1019), 1, anon_sym_LBRACE, - ACTIONS(1023), 1, - sym__statement_break, - STATE(1718), 1, + STATE(1370), 1, sym__call_type_arguments, ACTIONS(1001), 2, anon_sym_STAR, @@ -43284,59 +43329,116 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44417] = 3, - ACTIONS(3), 1, + [44417] = 16, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1238), 3, - anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1236), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_opaque, - anon_sym_signature, - sym_identifier, - [44446] = 3, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1236), 1, + anon_sym_LBRACE, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [44472] = 16, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(434), 1, + anon_sym_LBRACE, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [44527] = 8, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1242), 3, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + ACTIONS(981), 1, + anon_sym_LT, + ACTIONS(983), 1, + anon_sym_LBRACK, + ACTIONS(1238), 1, + anon_sym_LBRACE, + ACTIONS(1242), 1, + anon_sym_LPAREN, + STATE(397), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1240), 15, anon_sym_RBRACE, - anon_sym_BANG, - sym__doc_comment_line, - ACTIONS(1240), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, anon_sym_where, sym_static_stage, anon_sym_effect, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, - sym_identifier, - [44475] = 16, + sym__doc_comment_line, + [44566] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43354,12 +43456,51 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, ACTIONS(1244), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [44621] = 16, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1246), 1, + anon_sym_LBRACE, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43375,7 +43516,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44530] = 13, + [44676] = 13, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43386,11 +43527,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -43398,7 +43539,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(545), 2, + STATE(547), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -43406,12 +43547,77 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [44579] = 13, + [44725] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1250), 3, + anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1248), 18, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym_identifier, + [44754] = 16, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(432), 1, + anon_sym_DOT, + ACTIONS(442), 1, + anon_sym_QMARK, + ACTIONS(444), 1, + anon_sym_PIPE_PIPE, + ACTIONS(446), 1, + anon_sym_AMP_AMP, + ACTIONS(452), 1, + anon_sym_SLASH, + ACTIONS(454), 1, + anon_sym_PIPE_GT, + ACTIONS(456), 1, + anon_sym_LBRACK2, + ACTIONS(458), 1, + sym__call_open_gap, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1252), 1, + anon_sym_LBRACE, + STATE(1567), 1, + sym__call_type_arguments, + ACTIONS(438), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(440), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(450), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(448), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [44809] = 13, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43422,11 +43628,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -43434,7 +43640,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(552), 2, + STATE(575), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -43442,12 +43648,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [44628] = 16, + [44858] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43465,12 +43671,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1246), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1254), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43486,14 +43692,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [44683] = 3, + [44913] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1250), 3, + ACTIONS(1258), 3, anon_sym_RBRACE, anon_sym_BANG, sym__doc_comment_line, - ACTIONS(1248), 18, + ACTIONS(1256), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43512,14 +43718,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [44712] = 3, + [44942] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1254), 3, + ACTIONS(1262), 3, anon_sym_RBRACE, anon_sym_BANG, sym__doc_comment_line, - ACTIONS(1252), 18, + ACTIONS(1260), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43538,46 +43744,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [44741] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1256), 1, - anon_sym_LBRACE, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [44796] = 13, + [44971] = 13, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43588,11 +43755,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, STATE(1282), 1, sym_qualified_path, - STATE(1470), 1, + STATE(1537), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -43600,7 +43767,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1072), 2, anon_sym_true, anon_sym_false, - STATE(575), 2, + STATE(554), 2, sym_select_arm, aux_sym_select_expression_repeat1, ACTIONS(1066), 4, @@ -43608,19 +43775,19 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [44845] = 3, + [45020] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1260), 3, + ACTIONS(1266), 3, anon_sym_RBRACE, anon_sym_BANG, sym__doc_comment_line, - ACTIONS(1258), 18, + ACTIONS(1264), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43639,77 +43806,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym_identifier, - [44874] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(434), 1, - anon_sym_LBRACE, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [44929] = 8, + [45049] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(839), 1, - anon_sym_COLON_COLON, - ACTIONS(981), 1, - anon_sym_LT, - ACTIONS(983), 1, - anon_sym_LBRACK, - ACTIONS(1262), 1, - anon_sym_LBRACE, - ACTIONS(1266), 1, - anon_sym_LPAREN, - STATE(397), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1264), 15, + ACTIONS(1270), 3, anon_sym_RBRACE, + anon_sym_BANG, + sym__doc_comment_line, + ACTIONS(1268), 18, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_where, sym_static_stage, anon_sym_effect, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, - sym__doc_comment_line, - [44968] = 16, + sym_identifier, + [45078] = 16, ACTIONS(298), 1, sym_line_comment, ACTIONS(432), 1, @@ -43727,12 +43850,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(456), 1, anon_sym_LBRACK2, ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, sym__call_open_gap, - ACTIONS(1268), 1, + ACTIONS(460), 1, + sym__type_application_ahead, + ACTIONS(1272), 1, anon_sym_LBRACE, - STATE(1574), 1, + STATE(1567), 1, sym__call_type_arguments, ACTIONS(438), 2, anon_sym_STAR, @@ -43748,88 +43871,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [45023] = 16, + [45133] = 13, ACTIONS(298), 1, sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1270), 1, - anon_sym_LBRACE, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [45078] = 16, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(432), 1, - anon_sym_DOT, - ACTIONS(442), 1, - anon_sym_QMARK, - ACTIONS(444), 1, - anon_sym_PIPE_PIPE, - ACTIONS(446), 1, - anon_sym_AMP_AMP, - ACTIONS(452), 1, - anon_sym_SLASH, - ACTIONS(454), 1, - anon_sym_PIPE_GT, - ACTIONS(456), 1, - anon_sym_LBRACK2, - ACTIONS(458), 1, - anon_sym_LT2, - ACTIONS(460), 1, - sym__call_open_gap, - ACTIONS(1272), 1, - anon_sym_LBRACE, - STATE(1574), 1, - sym__call_type_arguments, - ACTIONS(438), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(440), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(450), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(448), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [45133] = 13, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1060), 1, + ACTIONS(1060), 1, anon_sym_LBRACE, ACTIONS(1064), 1, anon_sym_LPAREN, @@ -43837,13 +43882,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, ACTIONS(1274), 1, anon_sym_DOT_DOT_DOT, STATE(1282), 1, sym_qualified_path, - STATE(1351), 1, + STATE(1354), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -43856,12 +43901,39 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45181] = 13, + [45181] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1276), 1, + anon_sym_COLON_COLON, + STATE(628), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(419), 4, + anon_sym_COLON, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(421), 14, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + anon_sym_PLUS, + [45213] = 13, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43872,14 +43944,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1276), 1, - anon_sym_RBRACK, - STATE(1209), 1, - sym_pattern, + ACTIONS(1279), 1, + anon_sym_DOT_DOT_DOT, STATE(1282), 1, sym_qualified_path, + STATE(1354), 1, + sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, @@ -43891,12 +43963,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45229] = 13, + [45261] = 13, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43907,14 +43979,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - ACTIONS(1278), 1, - anon_sym_DOT_DOT_DOT, + ACTIONS(1281), 1, + anon_sym_RBRACK, + STATE(1185), 1, + sym_pattern, STATE(1282), 1, sym_qualified_path, - STATE(1351), 1, - sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, @@ -43926,12 +43998,39 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45277] = 12, + [45309] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(981), 1, + anon_sym_LT, + ACTIONS(983), 1, + anon_sym_LBRACK, + ACTIONS(1238), 1, + anon_sym_LBRACE, + ACTIONS(1242), 1, + anon_sym_LPAREN, + ACTIONS(1240), 15, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [45342] = 12, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -43942,12 +44041,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, - STATE(1244), 1, - sym_pattern, STATE(1282), 1, sym_qualified_path, + STATE(1295), 1, + sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, @@ -43959,66 +44058,36 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45322] = 6, - ACTIONS(3), 1, + [45387] = 3, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(839), 1, + ACTIONS(419), 4, + anon_sym_COLON, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(421), 15, + anon_sym_DOT, anon_sym_COLON_COLON, - ACTIONS(1262), 1, anon_sym_LBRACE, - ACTIONS(1266), 1, - anon_sym_LPAREN, - STATE(397), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1264), 15, anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [45355] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(981), 1, + anon_sym_COMMA, anon_sym_LT, - ACTIONS(983), 1, - anon_sym_LBRACK, - ACTIONS(1262), 1, - anon_sym_LBRACE, - ACTIONS(1266), 1, + anon_sym_GT, anon_sym_LPAREN, - ACTIONS(1264), 15, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, + anon_sym_RPAREN, anon_sym_PIPE, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [45388] = 12, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + anon_sym_PLUS, + [45414] = 12, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -44029,12 +44098,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, + STATE(1232), 1, + sym_pattern, STATE(1282), 1, sym_qualified_path, - STATE(1351), 1, - sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, anon_sym_DASH, @@ -44046,12 +44115,12 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45433] = 12, + [45459] = 12, ACTIONS(298), 1, sym_line_comment, ACTIONS(1060), 1, @@ -44062,11 +44131,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1074), 1, sym_float, - ACTIONS(1128), 1, + ACTIONS(1132), 1, sym_identifier, STATE(1282), 1, sym_qualified_path, - STATE(1296), 1, + STATE(1354), 1, sym_pattern, ACTIONS(1070), 2, anon_sym_PLUS, @@ -44079,12 +44148,39 @@ static const uint16_t ts_small_parse_table[] = { sym_integer, sym_string, sym_interpolated_string, - STATE(1076), 4, + STATE(1072), 4, sym_structural_pattern, sym_tuple_pattern, sym_list_pattern, sym_boolean, - [45478] = 14, + [45504] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(839), 1, + anon_sym_COLON_COLON, + ACTIONS(1238), 1, + anon_sym_LBRACE, + ACTIONS(1242), 1, + anon_sym_LPAREN, + STATE(397), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1240), 15, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_where, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [45537] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44093,32 +44189,32 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1280), 1, + ACTIONS(1283), 1, anon_sym_RBRACE, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(641), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45526] = 14, + [45585] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44127,32 +44223,32 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1292), 1, + ACTIONS(1295), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(642), 2, + STATE(637), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45574] = 14, + [45633] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44161,32 +44257,32 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1294), 1, + ACTIONS(1297), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(642), 2, + STATE(646), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45622] = 14, + [45681] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44195,66 +44291,91 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1296), 1, + ACTIONS(1299), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45670] = 14, + [45729] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + STATE(628), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(426), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(428), 13, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [45759] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(861), 1, - sym_static_stage, - ACTIONS(863), 1, - anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1303), 1, + anon_sym_RBRACE, + ACTIONS(1305), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1308), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1311), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1314), 1, + sym_static_stage, + ACTIONS(1317), 1, + anon_sym_effect, + ACTIONS(1320), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1323), 1, anon_sym_opaque, - ACTIONS(1298), 1, - anon_sym_RBRACE, + ACTIONS(1326), 1, + sym__doc_comment_line, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(638), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45718] = 14, + [45807] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44263,32 +44384,32 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1300), 1, + ACTIONS(1329), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(636), 2, + STATE(645), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45766] = 14, + [45855] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44297,66 +44418,66 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1302), 1, + ACTIONS(1331), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(642), 2, + STATE(640), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45814] = 14, + [45903] = 14, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1304), 1, - anon_sym_RBRACE, - ACTIONS(1306), 1, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(861), 1, + sym_static_stage, + ACTIONS(863), 1, + anon_sym_effect, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1309), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1312), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1315), 1, - sym_static_stage, - ACTIONS(1318), 1, - anon_sym_effect, - ACTIONS(1321), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1324), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1327), 1, - sym__doc_comment_line, + ACTIONS(1333), 1, + anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45862] = 14, + [45951] = 14, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, @@ -44365,39 +44486,39 @@ static const uint16_t ts_small_parse_table[] = { sym_static_stage, ACTIONS(863), 1, anon_sym_effect, - ACTIONS(1282), 1, + ACTIONS(1285), 1, anon_sym_let, - ACTIONS(1284), 1, + ACTIONS(1287), 1, anon_sym_fn, - ACTIONS(1286), 1, + ACTIONS(1289), 1, anon_sym_type, - ACTIONS(1288), 1, + ACTIONS(1291), 1, anon_sym_module, - ACTIONS(1290), 1, + ACTIONS(1293), 1, anon_sym_opaque, - ACTIONS(1330), 1, + ACTIONS(1335), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(1369), 1, + STATE(1321), 1, sym_doc_comment, - STATE(637), 2, + STATE(642), 2, sym_signature_item, aux_sym_signature_declaration_repeat1, - STATE(847), 5, + STATE(838), 5, sym_effect_declaration, sym_signature_value, sym_signature_function, sym_signature_type, sym_signature_module, - [45910] = 4, + [45999] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1262), 1, + ACTIONS(1238), 1, anon_sym_LBRACE, - ACTIONS(1266), 1, + ACTIONS(1242), 1, anon_sym_LPAREN, - ACTIONS(1264), 15, + ACTIONS(1240), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44413,14 +44534,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45937] = 4, + [46026] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1334), 1, + ACTIONS(1339), 1, anon_sym_PIPE, - STATE(646), 1, + STATE(648), 1, aux_sym_union_type_repeat1, - ACTIONS(1332), 14, + ACTIONS(1337), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44435,14 +44556,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45963] = 4, + [46052] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1334), 1, + ACTIONS(1344), 1, anon_sym_PIPE, - STATE(647), 1, + STATE(650), 1, aux_sym_union_type_repeat1, - ACTIONS(1336), 14, + ACTIONS(1342), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44457,14 +44578,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [45989] = 4, + [46078] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1340), 1, + ACTIONS(1344), 1, anon_sym_PIPE, - STATE(647), 1, + STATE(648), 1, aux_sym_union_type_repeat1, - ACTIONS(1338), 14, + ACTIONS(1346), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44479,37 +44600,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46015] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1343), 15, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_where, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [46036] = 7, + [46104] = 7, ACTIONS(298), 1, sym_line_comment, ACTIONS(977), 1, anon_sym_EQ, - ACTIONS(1345), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1347), 1, + ACTIONS(1348), 1, anon_sym_LT, - ACTIONS(1349), 1, + ACTIONS(1350), 1, anon_sym_LBRACK, - STATE(652), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, ACTIONS(979), 10, anon_sym_LBRACE, @@ -44522,18 +44624,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [46067] = 2, + [46135] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1338), 15, + ACTIONS(1354), 1, + anon_sym_where, + STATE(690), 1, + sym_type_validation, + ACTIONS(1352), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44541,58 +44645,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46088] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(419), 1, - anon_sym_EQ, - ACTIONS(1351), 1, - anon_sym_COLON_COLON, - STATE(651), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(421), 12, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46115] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(426), 1, - anon_sym_EQ, - ACTIONS(1345), 1, - anon_sym_COLON_COLON, - STATE(651), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(428), 12, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46142] = 4, + [46160] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 1, + ACTIONS(1354), 1, anon_sym_where, - STATE(690), 1, + STATE(727), 1, sym_type_validation, - ACTIONS(1354), 13, + ACTIONS(1356), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44606,18 +44666,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46167] = 2, + [46185] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1358), 15, + ACTIONS(1354), 1, + anon_sym_where, + STATE(732), 1, + sym_type_validation, + ACTIONS(1358), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44625,20 +44687,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46188] = 4, + [46210] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 1, - anon_sym_where, - STATE(727), 1, - sym_type_validation, - ACTIONS(1360), 13, + ACTIONS(1337), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44646,20 +44706,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46213] = 4, + [46231] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 1, - anon_sym_where, - STATE(732), 1, - sym_type_validation, - ACTIONS(1362), 13, + ACTIONS(1360), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44667,20 +44725,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46238] = 4, + [46252] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 1, - anon_sym_where, - STATE(716), 1, - sym_type_validation, - ACTIONS(1364), 13, + ACTIONS(1362), 15, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_PIPE, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, @@ -44688,10 +44744,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46263] = 2, + [46273] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1366), 14, + ACTIONS(1354), 1, + anon_sym_where, + STATE(716), 1, + sym_type_validation, + ACTIONS(1364), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44703,31 +44763,30 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46283] = 2, + [46298] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1368), 14, + ACTIONS(1366), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, + anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46303] = 2, + [46318] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1370), 14, + ACTIONS(1368), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44742,37 +44801,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46323] = 9, + [46338] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1370), 1, sym_identifier, - ACTIONS(1374), 1, + ACTIONS(1372), 1, anon_sym_LBRACE, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(632), 1, + STATE(631), 1, sym_qualified_path, - STATE(645), 1, + STATE(649), 1, sym_variant, - STATE(653), 3, + STATE(652), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(659), 5, + STATE(684), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46357] = 3, + [46372] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1382), 1, + ACTIONS(1380), 1, anon_sym_DASH_GT, - ACTIONS(1380), 13, + ACTIONS(1378), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44786,10 +44845,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46379] = 2, + [46394] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1384), 14, + ACTIONS(1382), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44804,10 +44863,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46399] = 2, + [46414] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1386), 14, + ACTIONS(1384), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44822,12 +44881,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46419] = 3, - ACTIONS(3), 1, + [46434] = 9, + ACTIONS(298), 1, sym_line_comment, + ACTIONS(1386), 1, + sym_identifier, + ACTIONS(1388), 1, + anon_sym_LBRACE, ACTIONS(1390), 1, + anon_sym_fn, + ACTIONS(1392), 1, + anon_sym_LPAREN, + STATE(936), 1, + sym_qualified_path, + STATE(1069), 1, + sym_variant, + STATE(1163), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(1273), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [46468] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1396), 1, anon_sym_DASH_GT, - ACTIONS(1388), 13, + ACTIONS(1394), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44841,10 +44925,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46441] = 2, + [46490] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1392), 14, + ACTIONS(1398), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44859,60 +44943,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46461] = 9, + [46510] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(1370), 1, sym_identifier, - ACTIONS(1396), 1, - anon_sym_LBRACE, - ACTIONS(1398), 1, - anon_sym_fn, - ACTIONS(1400), 1, - anon_sym_LPAREN, - STATE(942), 1, - sym_qualified_path, - STATE(1072), 1, - sym_variant, - STATE(1127), 3, - sym_union_type, - sym_type_alias, - sym_record_type, - STATE(1274), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [46495] = 9, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(1372), 1, - sym_identifier, - ACTIONS(1374), 1, anon_sym_LBRACE, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(632), 1, + STATE(631), 1, sym_qualified_path, - STATE(645), 1, + STATE(649), 1, sym_variant, - STATE(657), 3, + STATE(658), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(659), 5, + STATE(684), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46529] = 2, + [46544] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1402), 14, + ACTIONS(1400), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44927,12 +44986,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46549] = 3, + [46564] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1406), 1, + ACTIONS(1404), 1, anon_sym_DASH_GT, - ACTIONS(1404), 13, + ACTIONS(1402), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44946,10 +45005,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46571] = 2, + [46586] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1408), 14, + ACTIONS(1406), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44964,10 +45023,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46591] = 2, + [46606] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1410), 14, + ACTIONS(1408), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -44982,10 +45041,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46611] = 2, + [46626] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1412), 14, + ACTIONS(1410), 14, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -45000,12 +45059,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46631] = 3, + [46646] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1416), 1, + ACTIONS(1414), 1, anon_sym_DASH_GT, - ACTIONS(1414), 13, + ACTIONS(1412), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -45019,32 +45078,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [46653] = 9, + [46668] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1370), 1, sym_identifier, - ACTIONS(1374), 1, + ACTIONS(1372), 1, anon_sym_LBRACE, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(632), 1, + STATE(631), 1, sym_qualified_path, - STATE(645), 1, + STATE(649), 1, sym_variant, - STATE(656), 3, + STATE(654), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(659), 5, + STATE(684), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46687] = 2, + [46702] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1416), 14, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym__doc_comment_line, + [46722] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1418), 14, @@ -45062,7 +45139,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46707] = 2, + [46742] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1420), 14, @@ -45080,7 +45157,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46727] = 2, + [46762] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1422), 14, @@ -45098,7 +45175,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46747] = 2, + [46782] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1424), 14, @@ -45116,7 +45193,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46767] = 2, + [46802] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1426), 14, @@ -45134,7 +45211,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46787] = 2, + [46822] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1428), 14, @@ -45152,7 +45229,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46807] = 2, + [46842] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1430), 14, @@ -45170,7 +45247,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46827] = 2, + [46862] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1432), 14, @@ -45180,134 +45257,115 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, sym_static_stage, anon_sym_effect, anon_sym_state, anon_sym_module, anon_sym_export, - anon_sym_opaque, anon_sym_signature, sym__doc_comment_line, - [46847] = 9, + [46882] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(1386), 1, sym_identifier, - ACTIONS(1396), 1, + ACTIONS(1388), 1, anon_sym_LBRACE, - ACTIONS(1398), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - STATE(942), 1, + STATE(936), 1, sym_qualified_path, - STATE(1072), 1, + STATE(1069), 1, sym_variant, - STATE(1206), 3, + STATE(1229), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1274), 5, + STATE(1273), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46881] = 9, + [46916] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(1370), 1, sym_identifier, - ACTIONS(1396), 1, + ACTIONS(1372), 1, anon_sym_LBRACE, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(942), 1, + STATE(631), 1, sym_qualified_path, - STATE(1072), 1, + STATE(649), 1, sym_variant, - STATE(1212), 3, + STATE(653), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1274), 5, + STATE(684), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46915] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(419), 1, - anon_sym_EQ, - ACTIONS(421), 13, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LT, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [46937] = 9, + [46950] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1372), 1, + ACTIONS(1386), 1, sym_identifier, - ACTIONS(1374), 1, + ACTIONS(1388), 1, anon_sym_LBRACE, - ACTIONS(1376), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - STATE(632), 1, + STATE(936), 1, sym_qualified_path, - STATE(645), 1, + STATE(1069), 1, sym_variant, - STATE(655), 3, + STATE(1173), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(659), 5, + STATE(1273), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [46971] = 9, + [46984] = 9, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1394), 1, + ACTIONS(1386), 1, sym_identifier, - ACTIONS(1396), 1, + ACTIONS(1388), 1, anon_sym_LBRACE, - ACTIONS(1398), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - STATE(942), 1, + STATE(936), 1, sym_qualified_path, - STATE(1072), 1, + STATE(1069), 1, sym_variant, - STATE(1142), 3, + STATE(1240), 3, sym_union_type, sym_type_alias, sym_record_type, - STATE(1274), 5, + STATE(1273), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [47005] = 2, + [47018] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1434), 13, @@ -45324,7 +45382,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47024] = 2, + [47037] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1436), 13, @@ -45341,7 +45399,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47043] = 2, + [47056] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1438), 13, @@ -45358,7 +45416,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47062] = 2, + [47075] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1440), 13, @@ -45375,7 +45433,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47081] = 2, + [47094] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1442), 13, @@ -45392,7 +45450,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47100] = 2, + [47113] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1444), 13, @@ -45409,7 +45467,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47119] = 2, + [47132] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1446), 13, @@ -45426,7 +45484,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47138] = 2, + [47151] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1448), 13, @@ -45443,7 +45501,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47157] = 2, + [47170] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1450), 13, @@ -45460,7 +45518,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47176] = 2, + [47189] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1452), 13, @@ -45477,7 +45535,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47195] = 2, + [47208] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1454), 13, @@ -45494,7 +45552,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47214] = 2, + [47227] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1456), 13, @@ -45511,7 +45569,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47233] = 2, + [47246] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1458), 13, @@ -45528,7 +45586,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47252] = 2, + [47265] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1460), 13, @@ -45545,7 +45603,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47271] = 2, + [47284] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1462), 13, @@ -45562,7 +45620,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47290] = 2, + [47303] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1464), 13, @@ -45579,7 +45637,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47309] = 2, + [47322] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1466), 13, @@ -45596,18 +45654,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47328] = 6, + [47341] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1468), 1, + ACTIONS(839), 1, anon_sym_COLON_COLON, - ACTIONS(1472), 1, - anon_sym_LT2, - STATE(774), 1, + ACTIONS(1470), 1, + anon_sym_LT, + STATE(397), 1, aux_sym_qualified_path_repeat1, - STATE(892), 1, + STATE(835), 1, sym_type_arguments, - ACTIONS(1470), 9, + ACTIONS(1468), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -45617,7 +45675,24 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [47355] = 2, + [47368] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1472), 13, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [47387] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1474), 13, @@ -45634,7 +45709,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47374] = 2, + [47406] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1476), 13, @@ -45651,7 +45726,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47393] = 2, + [47425] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1478), 13, @@ -45668,7 +45743,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47412] = 2, + [47444] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1480), 13, @@ -45685,7 +45760,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47431] = 2, + [47463] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1482), 13, @@ -45702,7 +45777,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47450] = 2, + [47482] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1484), 13, @@ -45719,7 +45794,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47469] = 2, + [47501] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1486), 13, @@ -45736,7 +45811,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47488] = 2, + [47520] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1488), 13, @@ -45753,7 +45828,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47507] = 2, + [47539] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1490), 13, @@ -45770,7 +45845,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47526] = 2, + [47558] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1492), 13, @@ -45787,7 +45862,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47545] = 2, + [47577] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1494), 13, @@ -45804,7 +45879,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47564] = 2, + [47596] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1496), 13, @@ -45821,7 +45896,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47583] = 2, + [47615] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1498), 13, @@ -45838,7 +45913,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47602] = 2, + [47634] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1500), 13, @@ -45855,7 +45930,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47621] = 2, + [47653] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1502), 13, @@ -45872,7 +45947,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47640] = 2, + [47672] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1504), 13, @@ -45889,7 +45964,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47659] = 2, + [47691] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1506), 13, @@ -45906,7 +45981,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47678] = 2, + [47710] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1508), 13, @@ -45923,7 +45998,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47697] = 2, + [47729] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1510), 13, @@ -45940,7 +46015,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47716] = 2, + [47748] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1512), 13, @@ -45957,7 +46032,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47735] = 2, + [47767] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1514), 13, @@ -45974,7 +46049,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47754] = 2, + [47786] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1516), 13, @@ -45991,7 +46066,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47773] = 2, + [47805] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1518), 13, @@ -46008,7 +46083,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47792] = 2, + [47824] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1520), 13, @@ -46025,7 +46100,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47811] = 2, + [47843] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1522), 13, @@ -46042,7 +46117,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47830] = 2, + [47862] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1524), 13, @@ -46059,7 +46134,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47849] = 2, + [47881] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1526), 13, @@ -46076,7 +46151,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47868] = 2, + [47900] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1528), 13, @@ -46093,7 +46168,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47887] = 2, + [47919] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1530), 13, @@ -46110,7 +46185,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47906] = 2, + [47938] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1532), 13, @@ -46127,7 +46202,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47925] = 2, + [47957] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1534), 13, @@ -46144,7 +46219,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47944] = 2, + [47976] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1536), 13, @@ -46161,7 +46236,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47963] = 2, + [47995] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1538), 13, @@ -46178,7 +46253,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [47982] = 2, + [48014] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1540), 13, @@ -46195,7 +46270,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48001] = 2, + [48033] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1542), 13, @@ -46212,7 +46287,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48020] = 2, + [48052] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1544), 13, @@ -46229,7 +46304,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48039] = 2, + [48071] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1546), 13, @@ -46246,7 +46321,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48058] = 2, + [48090] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1548), 13, @@ -46263,7 +46338,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48077] = 2, + [48109] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1550), 13, @@ -46280,7 +46355,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48096] = 2, + [48128] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1552), 13, @@ -46297,7 +46372,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48115] = 2, + [48147] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1554), 13, @@ -46314,7 +46389,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48134] = 2, + [48166] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1556), 13, @@ -46331,7 +46406,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48153] = 2, + [48185] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1558), 13, @@ -46348,7 +46423,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48172] = 2, + [48204] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1560), 13, @@ -46365,10 +46440,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48191] = 2, + [48223] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1562), 13, + ACTIONS(664), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46382,10 +46457,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48210] = 2, + [48242] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1564), 13, + ACTIONS(554), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46399,10 +46474,30 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48229] = 2, + [48261] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(977), 1, + anon_sym_EQ, + ACTIONS(1348), 1, + anon_sym_LT, + ACTIONS(1350), 1, + anon_sym_LBRACK, + ACTIONS(979), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [48286] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(664), 13, + ACTIONS(1562), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46416,10 +46511,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48248] = 2, + [48305] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(554), 13, + ACTIONS(1564), 13, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -46433,7 +46528,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48267] = 2, + [48324] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1566), 13, @@ -46450,27 +46545,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48286] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(977), 1, - anon_sym_EQ, - ACTIONS(1347), 1, - anon_sym_LT, - ACTIONS(1349), 1, - anon_sym_LBRACK, - ACTIONS(979), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [48311] = 2, + [48343] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1568), 13, @@ -46487,7 +46562,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48330] = 2, + [48362] = 2, ACTIONS(3), 1, sym_line_comment, ACTIONS(1570), 13, @@ -46504,237 +46579,203 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_export, anon_sym_signature, sym__doc_comment_line, - [48349] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1572), 13, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_state, - anon_sym_module, - anon_sym_export, - anon_sym_signature, - sym__doc_comment_line, - [48368] = 10, + [48381] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1576), 1, + ACTIONS(1574), 1, anon_sym_RBRACE, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(795), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48402] = 10, + [48415] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1582), 1, + ACTIONS(1580), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(767), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48436] = 10, + [48449] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1584), 1, + ACTIONS(1582), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(764), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48470] = 5, + [48483] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1588), 1, - anon_sym_DASH_GT, - ACTIONS(1590), 1, - anon_sym_BANG, - STATE(849), 1, - sym_effect_set, - ACTIONS(1586), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, + ACTIONS(71), 1, sym__doc_comment_line, - [48494] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(419), 1, - anon_sym_COLON, - ACTIONS(1592), 1, - anon_sym_COLON_COLON, - STATE(764), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(421), 9, - anon_sym_DOT, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_LPAREN, - anon_sym_RBRACK, - anon_sym_PLUS, - anon_sym_LT2, + ACTIONS(1572), 1, sym_identifier, - [48518] = 10, + ACTIONS(1578), 1, + sym_replayable, + ACTIONS(1584), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(940), 1, + sym_multiplicity, + STATE(982), 1, + sym_doc_comment, + STATE(796), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1576), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [48517] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1595), 1, + ACTIONS(1586), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48552] = 10, + [48551] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1590), 1, + anon_sym_DASH_GT, + ACTIONS(1592), 1, + anon_sym_BANG, + STATE(844), 1, + sym_effect_set, + ACTIONS(1588), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [48575] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1597), 1, + ACTIONS(1594), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(771), 2, + STATE(770), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48586] = 8, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(1515), 1, - sym__call_type_list, - ACTIONS(1605), 2, - anon_sym_in, - anon_sym_out, - STATE(1221), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [48616] = 10, + [48609] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1607), 1, + ACTIONS(1596), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48650] = 5, + [48643] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1590), 1, + ACTIONS(1592), 1, anon_sym_BANG, - ACTIONS(1611), 1, + ACTIONS(1600), 1, anon_sym_DASH_GT, - STATE(869), 1, + STATE(864), 1, sym_effect_set, - ACTIONS(1609), 9, + ACTIONS(1598), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -46744,292 +46785,256 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [48674] = 10, + [48667] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1613), 1, + ACTIONS(1602), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(778), 2, + STATE(775), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48708] = 10, + [48701] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1615), 1, + ACTIONS(1604), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48742] = 10, + [48735] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1617), 1, + ACTIONS(1606), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(762), 2, + STATE(799), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48776] = 10, + [48769] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1619), 1, + ACTIONS(1608), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(761), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48810] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1468), 1, - anon_sym_COLON_COLON, - STATE(775), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(428), 10, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_LT2, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48832] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1621), 1, - anon_sym_COLON_COLON, - STATE(775), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(421), 10, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_LT2, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [48854] = 10, + [48803] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1624), 1, + ACTIONS(1610), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(797), 2, + STATE(763), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48888] = 10, + [48837] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1626), 1, + ACTIONS(1612), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(781), 2, + STATE(778), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48922] = 10, + [48871] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1628), 1, + ACTIONS(1614), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48956] = 10, + [48905] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1630), 1, + ACTIONS(1616), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(772), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [48990] = 10, + [48939] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1632), 1, + ACTIONS(1618), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(768), 2, + STATE(781), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49024] = 10, + [48973] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1634), 1, + ACTIONS(1620), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49058] = 5, + [49007] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1590), 1, + ACTIONS(1592), 1, anon_sym_BANG, - ACTIONS(1638), 1, + ACTIONS(1624), 1, anon_sym_DASH_GT, - STATE(891), 1, + STATE(884), 1, sym_effect_set, - ACTIONS(1636), 9, + ACTIONS(1622), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47039,184 +47044,182 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49082] = 10, + [49031] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1640), 1, + ACTIONS(1626), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(787), 2, + STATE(783), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49116] = 10, + [49065] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1642), 1, + ACTIONS(1628), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49150] = 10, + [49099] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1644), 1, + ACTIONS(1630), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(779), 2, + STATE(786), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49184] = 10, + [49133] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1646), 1, + ACTIONS(1632), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(789), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49218] = 10, - ACTIONS(3), 1, + [49167] = 8, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1580), 1, - sym_replayable, - ACTIONS(1648), 1, - anon_sym_RBRACE, - STATE(227), 1, - aux_sym_doc_comment_repeat1, - STATE(968), 1, - sym_multiplicity, - STATE(991), 1, - sym_doc_comment, - STATE(798), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [49252] = 10, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, + sym_qualified_path, + STATE(1604), 1, + sym__call_type_list, + ACTIONS(1640), 2, + anon_sym_in, + anon_sym_out, + STATE(1119), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [49197] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1650), 1, + ACTIONS(1642), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(792), 2, + STATE(789), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49286] = 10, + [49231] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1652), 1, + ACTIONS(1644), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49320] = 5, + [49265] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1590), 1, + ACTIONS(1592), 1, anon_sym_BANG, - ACTIONS(1656), 1, + ACTIONS(1648), 1, anon_sym_DASH_GT, - STATE(840), 1, + STATE(898), 1, sym_effect_set, - ACTIONS(1654), 9, + ACTIONS(1646), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47226,206 +47229,230 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49344] = 10, + [49289] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1658), 1, + ACTIONS(1650), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(794), 2, + STATE(791), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49378] = 10, + [49323] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1660), 1, + ACTIONS(1652), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49412] = 10, + [49357] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1662), 1, + ACTIONS(1654), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, + sym_doc_comment, + STATE(793), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + ACTIONS(1576), 3, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + [49391] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(1572), 1, + sym_identifier, + ACTIONS(1578), 1, + sym_replayable, + ACTIONS(1656), 1, + anon_sym_RBRACE, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(940), 1, + sym_multiplicity, + STATE(982), 1, sym_doc_comment, STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49446] = 10, + [49425] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1664), 1, + ACTIONS(1658), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(794), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49480] = 10, + [49459] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1666), 1, + ACTIONS(1660), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(760), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49514] = 10, + [49493] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1668), 1, + ACTIONS(1662), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49548] = 10, + [49527] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1670), 1, + ACTIONS(1664), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49582] = 10, + [49561] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1672), 1, + ACTIONS(1666), 1, sym_identifier, - ACTIONS(1675), 1, + ACTIONS(1669), 1, anon_sym_RBRACE, - ACTIONS(1680), 1, + ACTIONS(1674), 1, sym_replayable, - ACTIONS(1683), 1, + ACTIONS(1677), 1, sym__doc_comment_line, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(798), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1677), 3, + ACTIONS(1671), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49616] = 4, + [49595] = 4, ACTIONS(3), 1, sym_line_comment, ACTIONS(839), 1, anon_sym_COLON_COLON, - STATE(800), 1, + STATE(798), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1686), 10, + ACTIONS(1680), 10, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47436,14 +47463,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49638] = 4, + [49617] = 4, ACTIONS(3), 1, sym_line_comment, ACTIONS(839), 1, anon_sym_COLON_COLON, STATE(396), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1688), 10, + ACTIONS(1682), 10, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47454,79 +47481,91 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49660] = 10, + [49639] = 10, ACTIONS(3), 1, sym_line_comment, ACTIONS(71), 1, sym__doc_comment_line, - ACTIONS(1574), 1, + ACTIONS(1572), 1, sym_identifier, - ACTIONS(1580), 1, + ACTIONS(1578), 1, sym_replayable, - ACTIONS(1690), 1, + ACTIONS(1684), 1, anon_sym_RBRACE, STATE(227), 1, aux_sym_doc_comment_repeat1, - STATE(968), 1, + STATE(940), 1, sym_multiplicity, - STATE(991), 1, + STATE(982), 1, sym_doc_comment, - STATE(765), 2, + STATE(796), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [49694] = 10, - ACTIONS(3), 1, + [49673] = 3, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(1574), 1, - sym_identifier, - ACTIONS(1580), 1, - sym_replayable, - ACTIONS(1692), 1, + ACTIONS(1248), 1, + anon_sym_EQ, + ACTIONS(1250), 10, + anon_sym_LBRACE, anon_sym_RBRACE, - STATE(227), 1, - aux_sym_doc_comment_repeat1, - STATE(968), 1, - sym_multiplicity, - STATE(991), 1, - sym_doc_comment, - STATE(784), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - ACTIONS(1578), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [49728] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1590), 1, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, anon_sym_BANG, - STATE(909), 1, - sym_effect_set, - ACTIONS(1694), 9, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [49692] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1268), 1, + anon_sym_EQ, + ACTIONS(1270), 10, + anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_let, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [49711] = 8, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49749] = 4, + ACTIONS(1638), 1, + anon_sym_LPAREN, + ACTIONS(1686), 1, + anon_sym_RPAREN, + STATE(754), 1, + sym_qualified_path, + STATE(1546), 1, + sym_type_list, + STATE(1086), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [49740] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1590), 1, + ACTIONS(1592), 1, anon_sym_BANG, - STATE(893), 1, + STATE(872), 1, sym_effect_set, - ACTIONS(1696), 9, + ACTIONS(1688), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47536,95 +47575,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49770] = 4, - ACTIONS(3), 1, + [49761] = 11, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1700), 1, - anon_sym_EQ, - ACTIONS(1702), 1, - anon_sym_LT, - ACTIONS(1698), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1692), 1, anon_sym_fn, + ACTIONS(1694), 1, + anon_sym_extern, + ACTIONS(1696), 1, anon_sym_type, + ACTIONS(1698), 1, sym_static_stage, + ACTIONS(1700), 1, anon_sym_effect, + ACTIONS(1702), 1, + anon_sym_state, + ACTIONS(1704), 1, anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49791] = 3, + ACTIONS(1706), 1, + anon_sym_export, + ACTIONS(1708), 1, + anon_sym_signature, + ACTIONS(1690), 2, + anon_sym_let, + anon_sym_mut, + [49796] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(419), 1, - anon_sym_COLON, - ACTIONS(421), 10, - anon_sym_DOT, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_LPAREN, - anon_sym_RBRACK, - anon_sym_PLUS, - anon_sym_LT2, + ACTIONS(1634), 1, sym_identifier, - [49810] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1472), 1, - anon_sym_LT2, - STATE(892), 1, - sym_type_arguments, - ACTIONS(1470), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1636), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49831] = 2, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, + sym_qualified_path, + ACTIONS(1710), 2, + anon_sym_in, + anon_sym_out, + STATE(1272), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [49823] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(421), 11, - anon_sym_COLON_COLON, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_LT2, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [49848] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1258), 1, + ACTIONS(1714), 1, anon_sym_EQ, - ACTIONS(1260), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [49867] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1590), 1, - anon_sym_BANG, - STATE(881), 1, - sym_effect_set, - ACTIONS(1704), 9, + ACTIONS(1716), 1, + anon_sym_LT, + ACTIONS(1712), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47634,57 +47636,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49888] = 8, + [49844] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1706), 1, + ACTIONS(1718), 1, anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1370), 1, + STATE(1441), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [49917] = 11, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1710), 1, - anon_sym_fn, - ACTIONS(1712), 1, - anon_sym_extern, - ACTIONS(1714), 1, - anon_sym_type, - ACTIONS(1716), 1, - sym_static_stage, - ACTIONS(1718), 1, - anon_sym_effect, - ACTIONS(1720), 1, - anon_sym_state, - ACTIONS(1722), 1, - anon_sym_module, - ACTIONS(1724), 1, - anon_sym_export, - ACTIONS(1726), 1, - anon_sym_signature, - ACTIONS(1708), 2, - anon_sym_let, - anon_sym_mut, - [49952] = 3, + [49873] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1252), 1, + ACTIONS(1264), 1, anon_sym_EQ, - ACTIONS(1254), 10, + ACTIONS(1266), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -47695,14 +47673,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [49971] = 4, + [49892] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1730), 1, - anon_sym_EQ, - ACTIONS(1732), 1, - anon_sym_LT, - ACTIONS(1728), 9, + ACTIONS(1592), 1, + anon_sym_BANG, + STATE(899), 1, + sym_effect_set, + ACTIONS(1720), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47712,14 +47690,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [49992] = 4, + [49913] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1590), 1, + ACTIONS(1592), 1, anon_sym_BANG, - STATE(906), 1, + STATE(903), 1, sym_effect_set, - ACTIONS(1734), 9, + ACTIONS(1722), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -47729,32 +47707,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50013] = 7, + [49934] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - ACTIONS(1736), 2, - anon_sym_in, - anon_sym_out, - STATE(1313), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50040] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1248), 1, + ACTIONS(1256), 1, anon_sym_EQ, - ACTIONS(1250), 10, + ACTIONS(1258), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -47765,112 +47723,113 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [50059] = 8, + [49953] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1592), 1, + anon_sym_BANG, + STATE(887), 1, + sym_effect_set, + ACTIONS(1724), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [49974] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1738), 1, + ACTIONS(1726), 1, anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1602), 1, + STATE(1595), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50088] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1236), 1, - anon_sym_EQ, - ACTIONS(1238), 10, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [50107] = 8, + [50003] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1740), 1, + ACTIONS(1728), 1, anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1618), 1, + STATE(1611), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50136] = 8, + [50032] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1742), 1, + ACTIONS(1730), 1, anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1667), 1, + STATE(1660), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50165] = 8, + [50061] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1744), 1, + ACTIONS(1732), 1, anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1673), 1, + STATE(1666), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50194] = 3, + [50090] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1240), 1, + ACTIONS(1260), 1, anon_sym_EQ, - ACTIONS(1242), 10, + ACTIONS(1262), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -47881,51 +47840,132 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [50213] = 8, + [50109] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1470), 1, + anon_sym_LT, + STATE(835), 1, + sym_type_arguments, + ACTIONS(1468), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50130] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1736), 1, + anon_sym_EQ, + ACTIONS(1738), 1, + anon_sym_LT, + ACTIONS(1734), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50151] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1742), 1, + anon_sym_EQ, + ACTIONS(1740), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50169] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1746), 1, + anon_sym_EQ, + ACTIONS(1744), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [50187] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1746), 1, - anon_sym_RPAREN, - STATE(756), 1, + STATE(754), 1, + sym_qualified_path, + STATE(1597), 1, + sym_positional_payload, + STATE(1251), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [50213] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, sym_qualified_path, - STATE(1440), 1, + STATE(1410), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50242] = 7, + [50239] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1597), 1, + STATE(1427), 1, sym_positional_payload, - STATE(1208), 5, + STATE(1251), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50268] = 3, + [50265] = 3, ACTIONS(3), 1, sym_line_comment, ACTIONS(1750), 1, - anon_sym_EQ, + anon_sym_PLUS, ACTIONS(1748), 9, anon_sym_RBRACE, anon_sym_let, @@ -47936,204 +47976,187 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50286] = 4, + [50283] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - STATE(764), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(428), 8, - anon_sym_DOT, + ACTIONS(1752), 1, + sym_identifier, + ACTIONS(1754), 1, anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, + ACTIONS(1758), 1, + anon_sym_COLON, + ACTIONS(1760), 1, anon_sym_LPAREN, + STATE(641), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1756), 4, + anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, - anon_sym_LT2, - sym_identifier, - [50306] = 7, + anon_sym_EQ_GT, + [50311] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1756), 1, + STATE(1528), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50332] = 8, + [50337] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, - anon_sym_COLON_COLON, - ACTIONS(1754), 1, - sym_identifier, - ACTIONS(1756), 1, - anon_sym_LBRACE, - ACTIONS(1760), 1, - anon_sym_COLON, - ACTIONS(1762), 1, - anon_sym_LPAREN, - STATE(827), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1758), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [50360] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1445), 1, + STATE(1415), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50386] = 11, + [50363] = 11, ACTIONS(298), 1, sym_line_comment, ACTIONS(886), 1, anon_sym_COMMA, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1754), 1, + ACTIONS(1752), 1, sym_identifier, - ACTIONS(1756), 1, + ACTIONS(1754), 1, anon_sym_LBRACE, - ACTIONS(1758), 1, + ACTIONS(1756), 1, anon_sym_EQ_GT, - ACTIONS(1760), 1, + ACTIONS(1758), 1, anon_sym_COLON, - ACTIONS(1762), 1, + ACTIONS(1760), 1, anon_sym_LPAREN, - ACTIONS(1764), 1, + ACTIONS(1762), 1, anon_sym_RBRACE, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1218), 1, + STATE(1162), 1, aux_sym_field_pattern_repeat1, - [50420] = 7, + [50397] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1415), 1, + STATE(1749), 1, sym_type_list, - STATE(1091), 5, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50446] = 7, + [50423] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1432), 1, - sym_positional_payload, - STATE(1208), 5, + STATE(1444), 1, + sym_type_list, + STATE(1086), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50472] = 7, + [50449] = 10, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1692), 1, anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - ACTIONS(1766), 1, - anon_sym_LBRACE, - STATE(756), 1, - sym_qualified_path, - STATE(1107), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50498] = 7, + ACTIONS(1694), 1, + anon_sym_extern, + ACTIONS(1696), 1, + anon_sym_type, + ACTIONS(1698), 1, + sym_static_stage, + ACTIONS(1700), 1, + anon_sym_effect, + ACTIONS(1702), 1, + anon_sym_state, + ACTIONS(1704), 1, + anon_sym_module, + ACTIONS(1708), 1, + anon_sym_signature, + ACTIONS(1690), 2, + anon_sym_let, + anon_sym_mut, + [50481] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1764), 1, + anon_sym_LBRACE, + STATE(754), 1, sym_qualified_path, - STATE(1399), 1, - sym_type_list, - STATE(1091), 5, + STATE(1065), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50524] = 7, + [50507] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1533), 1, - sym_type_list, - STATE(1091), 5, + STATE(1411), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50550] = 3, + [50530] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1770), 1, - anon_sym_EQ, - ACTIONS(1768), 9, + ACTIONS(1766), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48143,47 +48166,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50568] = 3, - ACTIONS(3), 1, + [50545] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1774), 1, - anon_sym_PLUS, - ACTIONS(1772), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50586] = 10, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, + sym_qualified_path, + STATE(1055), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [50568] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1710), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1712), 1, - anon_sym_extern, - ACTIONS(1714), 1, - anon_sym_type, - ACTIONS(1716), 1, - sym_static_stage, - ACTIONS(1718), 1, - anon_sym_effect, - ACTIONS(1720), 1, - anon_sym_state, - ACTIONS(1722), 1, - anon_sym_module, - ACTIONS(1726), 1, - anon_sym_signature, - ACTIONS(1708), 2, - anon_sym_let, - anon_sym_mut, - [50618] = 2, + ACTIONS(1376), 1, + anon_sym_LPAREN, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, + sym_qualified_path, + STATE(954), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [50591] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1776), 9, + ACTIONS(1770), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48193,112 +48213,95 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50633] = 6, + [50606] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1768), 1, sym_identifier, - STATE(1095), 1, + STATE(518), 1, sym_qualified_path, - STATE(1306), 5, + STATE(957), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50656] = 6, + [50629] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(1057), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50679] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1768), 1, sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, + STATE(518), 1, sym_qualified_path, - STATE(1151), 5, + STATE(939), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50702] = 6, + [50652] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(948), 5, + STATE(941), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50725] = 6, + [50675] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(617), 5, + STATE(622), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50748] = 6, + [50698] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(947), 5, + STATE(803), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50771] = 2, + [50721] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1782), 9, + ACTIONS(1772), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48308,57 +48311,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50786] = 6, + [50736] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(810), 5, + STATE(1298), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50809] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1784), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [50824] = 6, + [50759] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1053), 5, + STATE(1196), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50847] = 2, + [50782] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1786), 9, + ACTIONS(1774), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48368,182 +48358,167 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [50862] = 6, + [50797] = 8, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, - anon_sym_fn, - ACTIONS(1378), 1, - anon_sym_LPAREN, + ACTIONS(1776), 1, + anon_sym_COLON_COLON, + ACTIONS(1778), 1, + anon_sym_LBRACE, ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, - sym_qualified_path, - STATE(611), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [50885] = 6, + anon_sym_LT, + ACTIONS(1782), 1, + anon_sym_LPAREN, + ACTIONS(1784), 1, + anon_sym_LBRACK, + STATE(857), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1240), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [50824] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1016), 5, + STATE(1446), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50908] = 6, + [50847] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1768), 1, sym_identifier, - STATE(1095), 1, + STATE(518), 1, sym_qualified_path, - STATE(1530), 5, + STATE(617), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50931] = 6, + [50870] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1446), 5, + STATE(1151), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50954] = 6, + [50893] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1786), 1, + sym_identifier, + STATE(1078), 1, sym_qualified_path, - STATE(1231), 5, + STATE(1588), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [50977] = 6, + [50916] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(1095), 1, + STATE(1078), 1, sym_qualified_path, - STATE(1583), 5, + STATE(1318), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51000] = 6, + [50939] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(612), 5, + STATE(1014), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51023] = 6, + [50962] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1768), 1, sym_identifier, - STATE(1095), 1, + STATE(518), 1, sym_qualified_path, - STATE(1319), 5, + STATE(621), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51046] = 6, + [50985] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(998), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51069] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(954), 5, + STATE(996), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51092] = 4, + [51008] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1788), 1, + ACTIONS(1776), 1, anon_sym_COLON_COLON, - STATE(864), 1, + STATE(859), 1, aux_sym_qualified_path_repeat1, ACTIONS(428), 7, sym__statement_break, @@ -48553,29 +48528,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_where, anon_sym_LBRACK, - [51111] = 6, + [51027] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(958), 5, + STATE(1259), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51134] = 4, + [51050] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1790), 1, + ACTIONS(1788), 1, anon_sym_COLON_COLON, - STATE(864), 1, + STATE(859), 1, aux_sym_qualified_path_repeat1, ACTIONS(421), 7, sym__statement_break, @@ -48585,78 +48560,78 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_where, anon_sym_LBRACK, - [51153] = 6, + [51069] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(959), 5, + STATE(960), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51176] = 6, + [51092] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(964), 5, + STATE(965), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51199] = 6, + [51115] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1284), 5, + STATE(938), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51222] = 6, + [51138] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(804), 5, + STATE(812), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51245] = 2, + [51161] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1793), 9, + ACTIONS(1791), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48666,159 +48641,125 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51260] = 6, + [51176] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(883), 5, + STATE(874), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51283] = 6, + [51199] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1275), 5, + STATE(945), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51306] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1795), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51321] = 6, + [51222] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1004), 5, + STATE(1005), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51344] = 6, + [51245] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1729), 5, + STATE(1473), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51367] = 6, - ACTIONS(298), 1, + [51268] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1793), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1400), 1, - anon_sym_LPAREN, - ACTIONS(1778), 1, - sym_identifier, - STATE(1095), 1, - sym_qualified_path, - STATE(1314), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51390] = 6, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51283] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(518), 1, + STATE(1078), 1, sym_qualified_path, - STATE(966), 5, + STATE(1313), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51413] = 6, + [51306] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(1474), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51436] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(943), 5, + STATE(1027), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51459] = 2, + [51329] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1797), 9, + ACTIONS(1795), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48828,27 +48769,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51474] = 6, + [51344] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1768), 1, sym_identifier, - STATE(1095), 1, + STATE(518), 1, sym_qualified_path, - STATE(1458), 5, + STATE(917), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51497] = 2, + [51367] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1799), 9, + ACTIONS(1797), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48858,27 +48799,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51512] = 6, + [51382] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1262), 5, + STATE(888), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51535] = 2, + [51405] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1801), 9, + ACTIONS(1799), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48888,10 +48829,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51550] = 2, + [51420] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1803), 9, + ACTIONS(1801), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -48901,121 +48842,112 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51565] = 6, + [51435] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(897), 5, + STATE(1021), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51588] = 2, - ACTIONS(3), 1, + [51458] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1805), 9, - anon_sym_RBRACE, - anon_sym_let, + ACTIONS(1390), 1, anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51603] = 6, + ACTIONS(1392), 1, + anon_sym_LPAREN, + ACTIONS(1786), 1, + sym_identifier, + STATE(1078), 1, + sym_qualified_path, + STATE(1461), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [51481] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1026), 5, + STATE(1734), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51626] = 6, + [51504] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(699), 5, + STATE(1525), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51649] = 6, + [51527] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(518), 1, + STATE(1078), 1, sym_qualified_path, - STATE(815), 5, + STATE(1505), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51672] = 6, + [51550] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(962), 5, + STATE(809), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51695] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1807), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [51710] = 2, + [51573] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1809), 9, + ACTIONS(1803), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49025,10 +48957,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51725] = 2, + [51588] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1811), 9, + ACTIONS(1805), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49038,61 +48970,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51740] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1376), 1, - anon_sym_fn, - ACTIONS(1378), 1, - anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, - sym_qualified_path, - STATE(715), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51763] = 6, + [51603] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1786), 1, sym_identifier, - STATE(518), 1, + STATE(1078), 1, sym_qualified_path, - STATE(912), 5, + STATE(1303), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51786] = 6, - ACTIONS(298), 1, + [51626] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1807), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1378), 1, - anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, - sym_qualified_path, - STATE(721), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51809] = 2, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [51641] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1813), 9, + ACTIONS(1809), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49102,146 +49013,129 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [51824] = 6, + [51656] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(970), 5, + STATE(715), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51847] = 6, + [51679] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(731), 5, + STATE(926), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51870] = 6, + [51702] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(971), 5, + STATE(721), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51893] = 6, + [51725] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(946), 5, + STATE(731), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51916] = 6, + [51748] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(1521), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [51939] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1768), 1, sym_identifier, - ACTIONS(1601), 1, - anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, + STATE(518), 1, sym_qualified_path, - STATE(1013), 5, + STATE(950), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51962] = 6, + [51771] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(960), 5, + STATE(951), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [51985] = 6, + [51794] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, - sym_identifier, - STATE(518), 1, + STATE(754), 1, sym_qualified_path, - STATE(803), 5, + STATE(1003), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52008] = 2, + [51817] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1815), 9, + ACTIONS(1811), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49251,27 +49145,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [52023] = 6, + [51832] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(914), 5, + STATE(810), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52046] = 2, + [51855] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1817), 9, + ACTIONS(1813), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49281,10 +49175,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [52061] = 2, + [51870] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1819), 9, + ACTIONS(1815), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49294,74 +49188,61 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [52076] = 6, + [51885] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(952), 5, + STATE(953), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52099] = 6, + [51908] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(944), 5, + STATE(955), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52122] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1821), 9, - anon_sym_RBRACE, - anon_sym_let, - anon_sym_fn, - anon_sym_type, - sym_static_stage, - anon_sym_effect, - anon_sym_module, - anon_sym_opaque, - sym__doc_comment_line, - [52137] = 6, + [51931] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1376), 5, + STATE(964), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52160] = 2, + [51954] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1823), 9, + ACTIONS(1817), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -49371,6528 +49252,6598 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_module, anon_sym_opaque, sym__doc_comment_line, - [52175] = 6, + [51969] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, - anon_sym_LPAREN, - STATE(756), 1, - sym_qualified_path, - STATE(1396), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [52198] = 6, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(1376), 1, - anon_sym_fn, - ACTIONS(1378), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + ACTIONS(1768), 1, sym_identifier, STATE(518), 1, sym_qualified_path, - STATE(851), 5, + STATE(949), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52221] = 6, + [51992] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(823), 5, + STATE(1699), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52244] = 6, + [52015] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1416), 5, + STATE(961), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52267] = 6, + [52038] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, sym_qualified_path, - STATE(1417), 5, + STATE(947), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52290] = 6, + [52061] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1426), 5, + STATE(1371), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52313] = 6, + [52084] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1390), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1392), 1, anon_sym_LPAREN, - STATE(756), 1, + ACTIONS(1786), 1, + sym_identifier, + STATE(1078), 1, sym_qualified_path, - STATE(1012), 5, + STATE(1552), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52336] = 8, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1788), 1, - anon_sym_COLON_COLON, - ACTIONS(1825), 1, - anon_sym_LBRACE, - ACTIONS(1827), 1, - anon_sym_LT, - ACTIONS(1829), 1, - anon_sym_LPAREN, - ACTIONS(1831), 1, - anon_sym_LBRACK, - STATE(862), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1264), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [52363] = 6, + [52107] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1015), 5, + STATE(1391), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52386] = 6, + [52130] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1017), 5, + STATE(1281), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52409] = 6, + [52153] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1668), 5, + STATE(800), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52432] = 6, + [52176] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1020), 5, + STATE(817), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52455] = 6, + [52199] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1022), 5, + STATE(1412), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52478] = 6, + [52222] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1023), 5, + STATE(1421), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52501] = 6, + [52245] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1024), 5, + STATE(1008), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52524] = 6, - ACTIONS(298), 1, + [52268] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1599), 1, - sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1819), 9, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1603), 1, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52283] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1025), 5, + STATE(1011), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52547] = 6, + [52306] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1258), 5, + STATE(1013), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52570] = 6, + [52329] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1528), 5, + STATE(1016), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52593] = 6, + [52352] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(817), 5, + STATE(1017), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52616] = 6, + [52375] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1534), 5, + STATE(1018), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52639] = 6, + [52398] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1535), 5, + STATE(1019), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52662] = 6, + [52421] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(1049), 5, + STATE(1020), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52444] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, + sym_qualified_path, + STATE(1523), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52685] = 6, + [52467] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1821), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + sym_static_stage, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [52482] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1398), 1, + ACTIONS(1374), 1, anon_sym_fn, - ACTIONS(1400), 1, + ACTIONS(1376), 1, anon_sym_LPAREN, - ACTIONS(1778), 1, + ACTIONS(1768), 1, sym_identifier, - STATE(1095), 1, + STATE(518), 1, sym_qualified_path, - STATE(1498), 5, + STATE(847), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52708] = 6, + [52505] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(1634), 1, sym_identifier, - ACTIONS(1601), 1, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1603), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - STATE(756), 1, + STATE(754), 1, sym_qualified_path, - STATE(819), 5, + STATE(1529), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52731] = 6, + [52528] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1376), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, anon_sym_fn, - ACTIONS(1378), 1, + ACTIONS(1638), 1, anon_sym_LPAREN, - ACTIONS(1780), 1, + STATE(754), 1, + sym_qualified_path, + STATE(1530), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52551] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1634), 1, sym_identifier, - STATE(518), 1, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, sym_qualified_path, - STATE(963), 5, + STATE(811), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [52754] = 2, + [52574] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(421), 8, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_LT, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, anon_sym_LPAREN, - anon_sym_PIPE, - anon_sym_where, - anon_sym_LBRACK, - [52768] = 6, + STATE(754), 1, + sym_qualified_path, + STATE(1227), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52597] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1634), 1, + sym_identifier, + ACTIONS(1636), 1, + anon_sym_fn, + ACTIONS(1638), 1, + anon_sym_LPAREN, + STATE(754), 1, + sym_qualified_path, + STATE(1049), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52620] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1374), 1, + anon_sym_fn, + ACTIONS(1376), 1, + anon_sym_LPAREN, + ACTIONS(1768), 1, + sym_identifier, + STATE(518), 1, + sym_qualified_path, + STATE(699), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [52643] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - STATE(827), 1, + ACTIONS(1823), 1, + anon_sym_LT, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1085), 1, + STATE(1097), 1, sym_type_arguments, - ACTIONS(1470), 4, + ACTIONS(1468), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, anon_sym_RBRACK, - [52790] = 6, + [52665] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1825), 1, + ACTIONS(421), 8, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_where, + anon_sym_LBRACK, + [52679] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1778), 1, anon_sym_LBRACE, - ACTIONS(1827), 1, + ACTIONS(1780), 1, anon_sym_LT, - ACTIONS(1829), 1, + ACTIONS(1782), 1, anon_sym_LPAREN, - ACTIONS(1831), 1, + ACTIONS(1784), 1, anon_sym_LBRACK, - ACTIONS(1264), 3, + ACTIONS(1240), 3, sym__statement_break, anon_sym_PIPE, anon_sym_where, - [52811] = 3, - ACTIONS(3), 1, + [52700] = 7, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1837), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1835), 5, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - sym_replayable, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - [52826] = 3, + STATE(641), 1, + aux_sym_qualified_path_repeat1, + STATE(1126), 1, + sym_type_arguments, + STATE(1024), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [52723] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1841), 2, + ACTIONS(1829), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1839), 5, + ACTIONS(1827), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52841] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1788), 1, - anon_sym_COLON_COLON, - ACTIONS(1825), 1, - anon_sym_LBRACE, - ACTIONS(1829), 1, - anon_sym_LPAREN, - STATE(862), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1264), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [52862] = 3, + [52738] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1845), 2, + ACTIONS(1833), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1843), 5, + ACTIONS(1831), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52877] = 3, - ACTIONS(3), 1, + [52753] = 6, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(1849), 2, - anon_sym_RBRACE, - sym__doc_comment_line, - ACTIONS(1847), 5, + ACTIONS(1835), 1, + sym_identifier, + ACTIONS(1837), 1, + anon_sym_COLON, + ACTIONS(1839), 1, + sym_replayable, + STATE(1518), 1, + sym_multiplicity, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - sym_replayable, - sym_identifier, - [52892] = 3, + [52774] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1853), 2, + ACTIONS(1843), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1851), 5, + ACTIONS(1841), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52907] = 6, + [52789] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1855), 1, + ACTIONS(1845), 1, sym_identifier, - ACTIONS(1857), 1, + ACTIONS(1847), 1, anon_sym_COLON, - ACTIONS(1859), 1, + ACTIONS(1849), 1, sym_replayable, - STATE(1632), 1, + STATE(1631), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [52928] = 6, + [52810] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1861), 1, + ACTIONS(1851), 1, sym_identifier, - ACTIONS(1863), 1, + ACTIONS(1853), 1, anon_sym_COLON, - ACTIONS(1865), 1, + ACTIONS(1855), 1, sym_replayable, - STATE(1640), 1, + STATE(1638), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [52949] = 6, + [52831] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1863), 1, + ACTIONS(1853), 1, anon_sym_COLON, - ACTIONS(1867), 1, + ACTIONS(1857), 1, sym_identifier, - ACTIONS(1869), 1, + ACTIONS(1859), 1, sym_replayable, - STATE(1649), 1, + STATE(1648), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [52970] = 3, + [52852] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1873), 2, + ACTIONS(1863), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1871), 5, + ACTIONS(1861), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [52985] = 7, + [52867] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1182), 1, + STATE(1176), 1, sym_type_arguments, - STATE(997), 2, + STATE(992), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53008] = 3, + [52890] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1879), 2, + ACTIONS(1867), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1877), 5, + ACTIONS(1865), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53023] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1752), 1, - anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, - sym_identifier, - STATE(827), 1, - aux_sym_qualified_path_repeat1, - STATE(1189), 1, - sym_type_arguments, - STATE(1001), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53046] = 7, + [52905] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1160), 1, + STATE(1183), 1, sym_type_arguments, - STATE(1034), 2, + STATE(1000), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53069] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1881), 1, - sym_identifier, - ACTIONS(1883), 1, - anon_sym_COLON, - ACTIONS(1885), 1, - sym_replayable, - STATE(1695), 1, - sym_multiplicity, - ACTIONS(1578), 3, - anon_sym_abort, - anon_sym_once, - anon_sym_many, - [53090] = 3, + [52928] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1889), 2, + ACTIONS(1871), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1887), 5, + ACTIONS(1869), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53105] = 3, + [52943] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1893), 2, + ACTIONS(1875), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1891), 5, + ACTIONS(1873), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53120] = 3, + [52958] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1897), 2, + ACTIONS(1879), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1895), 5, + ACTIONS(1877), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53135] = 6, + [52973] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1899), 1, + ACTIONS(1881), 1, sym_identifier, - ACTIONS(1901), 1, + ACTIONS(1883), 1, anon_sym_COLON, - ACTIONS(1903), 1, + ACTIONS(1885), 1, sym_replayable, - STATE(1473), 1, + STATE(1744), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [53156] = 3, + [52994] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1907), 2, + ACTIONS(1889), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1905), 5, + ACTIONS(1887), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53171] = 3, + [53009] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1911), 2, + ACTIONS(1893), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1909), 5, + ACTIONS(1891), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53186] = 3, + [53024] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1915), 2, + ACTIONS(1897), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1913), 5, + ACTIONS(1895), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53201] = 7, + [53039] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1776), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, - sym_identifier, - STATE(827), 1, + ACTIONS(1778), 1, + anon_sym_LBRACE, + ACTIONS(1782), 1, + anon_sym_LPAREN, + STATE(857), 1, aux_sym_qualified_path_repeat1, - STATE(1228), 1, - sym_type_arguments, - STATE(1027), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53224] = 3, + ACTIONS(1240), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [53060] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1919), 2, + ACTIONS(1901), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1917), 5, + ACTIONS(1899), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53239] = 7, + [53075] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1232), 1, + STATE(1222), 1, sym_type_arguments, - STATE(1029), 2, + STATE(1023), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [53098] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, + sym_identifier, + STATE(641), 1, + aux_sym_qualified_path_repeat1, + STATE(1226), 1, + sym_type_arguments, + STATE(1025), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53262] = 6, + [53121] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1905), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1903), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [53136] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1909), 2, + anon_sym_RBRACE, + sym__doc_comment_line, + ACTIONS(1907), 5, + anon_sym_abort, + anon_sym_once, + anon_sym_many, + sym_replayable, + sym_identifier, + [53151] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1901), 1, + ACTIONS(1837), 1, anon_sym_COLON, - ACTIONS(1921), 1, + ACTIONS(1911), 1, sym_identifier, - ACTIONS(1923), 1, + ACTIONS(1913), 1, sym_replayable, - STATE(1516), 1, + STATE(1472), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [53283] = 7, + [53172] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1220), 1, + STATE(1204), 1, sym_type_arguments, - STATE(1003), 2, + STATE(1051), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53306] = 3, + [53195] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1927), 2, + ACTIONS(1917), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1925), 5, + ACTIONS(1915), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53321] = 3, + [53210] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1931), 2, + ACTIONS(1921), 2, anon_sym_RBRACE, sym__doc_comment_line, - ACTIONS(1929), 5, + ACTIONS(1919), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53336] = 7, + [53225] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1935), 1, + ACTIONS(1925), 1, anon_sym_EQ, - ACTIONS(1937), 1, + ACTIONS(1927), 1, anon_sym_DASH_GT, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - STATE(757), 1, + STATE(703), 1, sym_block, - STATE(1192), 1, + STATE(1201), 1, sym_effect_set, - [53358] = 7, + [53247] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1941), 1, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(1933), 1, anon_sym_EQ, - ACTIONS(1943), 1, + ACTIONS(1935), 1, anon_sym_DASH_GT, - STATE(692), 1, - sym_block, - STATE(1259), 1, + STATE(1257), 1, sym_effect_set, - [53380] = 7, + STATE(1533), 1, + sym_block, + [53269] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1945), 1, + ACTIONS(1937), 1, anon_sym_EQ, - ACTIONS(1947), 1, - anon_sym_DASH_GT, - STATE(738), 1, - sym_block, - STATE(1261), 1, - sym_effect_set, - [53402] = 7, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(1951), 1, - anon_sym_EQ, - ACTIONS(1953), 1, anon_sym_DASH_GT, - STATE(1219), 1, - sym_effect_set, - STATE(1419), 1, + STATE(722), 1, sym_block, - [53424] = 7, + STATE(1160), 1, + sym_effect_set, + [53291] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1805), 6, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1955), 1, + anon_sym_COMMA, anon_sym_EQ, - ACTIONS(1957), 1, - anon_sym_DASH_GT, - STATE(710), 1, - sym_block, - STATE(1222), 1, - sym_effect_set, - [53446] = 7, + anon_sym_RBRACK, + sym_identifier, + [53303] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(1959), 1, + ACTIONS(1941), 1, anon_sym_EQ, - ACTIONS(1961), 1, + ACTIONS(1943), 1, anon_sym_DASH_GT, - STATE(1147), 1, + STATE(1194), 1, sym_effect_set, - STATE(1631), 1, + STATE(1573), 1, sym_block, - [53468] = 4, + [53325] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - STATE(1085), 1, - sym_type_arguments, - ACTIONS(1470), 4, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - [53484] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(1963), 1, + ACTIONS(1945), 1, anon_sym_EQ, - ACTIONS(1965), 1, + ACTIONS(1947), 1, anon_sym_DASH_GT, - STATE(1256), 1, + STATE(1124), 1, sym_effect_set, - STATE(1444), 1, + STATE(1576), 1, sym_block, - [53506] = 2, + [53347] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1803), 6, - anon_sym_DOT, + ACTIONS(1923), 1, anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_RBRACK, - sym_identifier, - [53518] = 7, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(1967), 1, anon_sym_EQ, - ACTIONS(1969), 1, + ACTIONS(1951), 1, anon_sym_DASH_GT, - STATE(1197), 1, - sym_effect_set, - STATE(1565), 1, + STATE(757), 1, sym_block, - [53540] = 7, + STATE(1175), 1, + sym_effect_set, + [53369] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1971), 1, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(1953), 1, anon_sym_EQ, - ACTIONS(1973), 1, + ACTIONS(1955), 1, anon_sym_DASH_GT, - STATE(718), 1, - sym_block, - STATE(1169), 1, + STATE(1152), 1, sym_effect_set, - [53562] = 3, + STATE(1737), 1, + sym_block, + [53391] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1977), 1, + ACTIONS(1959), 1, anon_sym_COLON, - ACTIONS(1975), 5, + ACTIONS(1957), 5, anon_sym_abort, anon_sym_once, anon_sym_many, sym_replayable, sym_identifier, - [53576] = 6, + [53405] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1788), 1, - anon_sym_COLON_COLON, - ACTIONS(1827), 1, - anon_sym_LT, - ACTIONS(1831), 1, - anon_sym_LBRACK, - STATE(862), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(979), 2, - sym__statement_break, - anon_sym_where, - [53596] = 7, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1961), 1, + anon_sym_EQ, + ACTIONS(1963), 1, + anon_sym_DASH_GT, + STATE(759), 1, + sym_block, + STATE(1242), 1, + sym_effect_set, + [53427] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(1979), 1, + ACTIONS(1965), 1, anon_sym_EQ, - ACTIONS(1981), 1, + ACTIONS(1967), 1, anon_sym_DASH_GT, - STATE(1141), 1, + STATE(1225), 1, sym_effect_set, - STATE(1433), 1, + STATE(1564), 1, sym_block, - [53618] = 7, + [53449] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1983), 1, + ACTIONS(1969), 1, anon_sym_EQ, - ACTIONS(1985), 1, + ACTIONS(1971), 1, anon_sym_DASH_GT, - STATE(759), 1, + STATE(728), 1, sym_block, - STATE(1249), 1, + STATE(1243), 1, sym_effect_set, - [53640] = 7, + [53471] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(1987), 1, + ACTIONS(1973), 1, anon_sym_EQ, - ACTIONS(1989), 1, + ACTIONS(1975), 1, anon_sym_DASH_GT, - STATE(1235), 1, + STATE(1127), 1, sym_effect_set, - STATE(1566), 1, + STATE(1634), 1, sym_block, - [53662] = 7, + [53493] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1991), 1, + ACTIONS(1977), 1, anon_sym_EQ, - ACTIONS(1993), 1, + ACTIONS(1979), 1, anon_sym_DASH_GT, - STATE(703), 1, + STATE(692), 1, sym_block, - STATE(1216), 1, + STATE(1249), 1, sym_effect_set, - [53684] = 7, + [53515] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1995), 1, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(1981), 1, anon_sym_EQ, - ACTIONS(1997), 1, + ACTIONS(1983), 1, anon_sym_DASH_GT, - STATE(728), 1, - sym_block, - STATE(1251), 1, + STATE(1236), 1, sym_effect_set, - [53706] = 7, + STATE(1423), 1, + sym_block, + [53537] = 7, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(1999), 1, + ACTIONS(1985), 1, anon_sym_EQ, - ACTIONS(2001), 1, + ACTIONS(1987), 1, anon_sym_DASH_GT, - STATE(1237), 1, + STATE(1129), 1, sym_effect_set, - STATE(1518), 1, + STATE(1448), 1, sym_block, - [53728] = 5, + [53559] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2003), 1, + ACTIONS(1989), 1, sym_identifier, - ACTIONS(2005), 1, + ACTIONS(1991), 1, sym_replayable, - STATE(951), 1, + STATE(944), 1, sym_multiplicity, - ACTIONS(1578), 3, + ACTIONS(1576), 3, anon_sym_abort, anon_sym_once, anon_sym_many, - [53746] = 7, + [53577] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2007), 1, - anon_sym_EQ, - ACTIONS(2009), 1, - anon_sym_DASH_GT, - STATE(1253), 1, - sym_effect_set, - STATE(1651), 1, - sym_block, - [53768] = 5, + ACTIONS(1776), 1, + anon_sym_COLON_COLON, + ACTIONS(1780), 1, + anon_sym_LT, + ACTIONS(1784), 1, + anon_sym_LBRACK, + STATE(857), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(979), 2, + sym__statement_break, + anon_sym_where, + [53597] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, - sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1702), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [53785] = 5, + ACTIONS(1823), 1, + anon_sym_LT, + STATE(1097), 1, + sym_type_arguments, + ACTIONS(1468), 4, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + [53613] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1993), 1, + anon_sym_EQ, + ACTIONS(1995), 1, + anon_sym_DASH_GT, + STATE(738), 1, + sym_block, + STATE(1255), 1, + sym_effect_set, + [53635] = 7, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1997), 1, + anon_sym_EQ, + ACTIONS(1999), 1, + anon_sym_DASH_GT, + STATE(711), 1, + sym_block, + STATE(1213), 1, + sym_effect_set, + [53657] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1386), 1, + STATE(1695), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [53802] = 5, + [53674] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(859), 1, + anon_sym_type, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(749), 1, + sym_type_declaration, + STATE(1742), 1, + sym_doc_comment, + [53693] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2017), 1, + ACTIONS(2007), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1469), 1, + STATE(1485), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [53819] = 5, + [53710] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1394), 1, + STATE(1457), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [53836] = 4, + [53727] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2001), 1, sym_identifier, - ACTIONS(2021), 2, + STATE(1203), 1, + sym_type_parameter, + STATE(1393), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, + anon_sym_in, + anon_sym_out, + [53744] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2009), 1, + sym_identifier, + ACTIONS(2011), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53851] = 6, + [53759] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(2013), 1, + anon_sym_RPAREN, + STATE(1073), 1, + sym_parameter, + STATE(1484), 1, + sym_parameter_list, + ACTIONS(2005), 2, + anon_sym__, + sym_identifier, + [53776] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2001), 1, + sym_identifier, + STATE(1203), 1, + sym_type_parameter, + STATE(1476), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, + anon_sym_in, + anon_sym_out, + [53793] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2015), 1, + anon_sym_RPAREN, + STATE(1073), 1, + sym_parameter, + STATE(1479), 1, + sym_parameter_list, + ACTIONS(2005), 2, + anon_sym__, + sym_identifier, + [53810] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2023), 1, + ACTIONS(2017), 1, anon_sym_EQ, - STATE(1179), 1, + STATE(1157), 1, sym_effect_set, - STATE(1646), 1, + STATE(1650), 1, sym_block, - [53870] = 5, + [53829] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1478), 1, + STATE(1483), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [53887] = 5, + [53846] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2025), 1, - anon_sym_RPAREN, - STATE(1108), 1, - sym_parameter, - STATE(1480), 1, - sym_parameter_list, - ACTIONS(2015), 2, - anon_sym__, + ACTIONS(1778), 1, + anon_sym_LBRACE, + ACTIONS(1782), 1, + anon_sym_LPAREN, + ACTIONS(1240), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [53861] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2001), 1, sym_identifier, - [53904] = 4, + STATE(1203), 1, + sym_type_parameter, + STATE(1401), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, + anon_sym_in, + anon_sym_out, + [53878] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2027), 2, + ACTIONS(2019), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53919] = 4, + [53893] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2029), 2, + ACTIONS(2021), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [53934] = 4, + [53908] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2001), 1, sym_identifier, - ACTIONS(2031), 2, + STATE(1203), 1, + sym_type_parameter, + STATE(1652), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, anon_sym_in, - anon_sym_do, - STATE(1047), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [53949] = 6, + anon_sym_out, + [53925] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2033), 1, + ACTIONS(2023), 1, anon_sym_EQ, - STATE(1123), 1, + STATE(1205), 1, sym_effect_set, - STATE(1658), 1, + STATE(1508), 1, sym_block, - [53968] = 5, + [53944] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1463), 1, + STATE(1490), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [53985] = 4, + [53961] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2025), 1, + anon_sym_EQ, + STATE(1223), 1, + sym_effect_set, + STATE(1661), 1, + sym_block, + [53980] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2035), 2, + ACTIONS(2027), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54000] = 5, + [53995] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, - sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1484), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [54017] = 5, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2029), 1, + anon_sym_DOT, + STATE(641), 1, + aux_sym_qualified_path_repeat1, + STATE(1663), 1, + sym_type_arguments, + [54014] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(2031), 1, + anon_sym_EQ, + STATE(697), 1, + sym_block, + STATE(1189), 1, + sym_effect_set, + [54033] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1491), 1, + STATE(1486), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [54034] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1825), 1, - anon_sym_LBRACE, - ACTIONS(1829), 1, - anon_sym_LPAREN, - ACTIONS(1264), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [54049] = 5, + [54050] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1483), 1, + STATE(1417), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [54066] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2037), 1, - anon_sym_RPAREN, - STATE(1108), 1, - sym_parameter, - STATE(1476), 1, - sym_parameter_list, - ACTIONS(2015), 2, - anon_sym__, - sym_identifier, - [54083] = 6, + [54067] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2039), 1, + ACTIONS(2033), 1, anon_sym_EQ, - STATE(697), 1, + STATE(714), 1, sym_block, - STATE(1207), 1, - sym_effect_set, - [54102] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2041), 1, - anon_sym_EQ, - STATE(1193), 1, + STATE(1220), 1, sym_effect_set, - STATE(1479), 1, - sym_block, - [54121] = 5, + [54086] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2043), 1, + ACTIONS(2035), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1487), 1, + STATE(1492), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54138] = 6, + [54103] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2045), 1, + ACTIONS(2037), 1, anon_sym_EQ, - STATE(713), 1, + STATE(719), 1, sym_block, - STATE(1226), 1, + STATE(1230), 1, sym_effect_set, - [54157] = 6, + [54122] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2047), 1, + ACTIONS(2039), 1, anon_sym_EQ, - STATE(1205), 1, + STATE(1206), 1, sym_effect_set, - STATE(1490), 1, - sym_block, - [54176] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(2049), 1, - anon_sym_EQ, - STATE(719), 1, + STATE(1497), 1, sym_block, - STATE(1234), 1, - sym_effect_set, - [54195] = 5, + [54141] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2051), 1, - anon_sym_PIPE, - STATE(1108), 1, - sym_parameter, - STATE(1564), 1, - sym_parameter_list, - ACTIONS(2015), 2, - anon_sym__, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - [54212] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1752), 1, - anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2053), 1, - anon_sym_DOT, - STATE(827), 1, - aux_sym_qualified_path_repeat1, - STATE(1608), 1, + STATE(1204), 1, sym_type_arguments, - [54231] = 6, + STATE(1051), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54158] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2055), 1, + ACTIONS(2041), 1, anon_sym_EQ, STATE(730), 1, sym_block, - STATE(1255), 1, + STATE(1247), 1, sym_effect_set, - [54250] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, - sym_identifier, - STATE(1220), 1, - sym_type_arguments, - STATE(1003), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54267] = 6, + [54177] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2057), 1, + ACTIONS(2043), 1, anon_sym_EQ, STATE(735), 1, sym_block, - STATE(1257), 1, + STATE(1250), 1, sym_effect_set, - [54286] = 6, + [54196] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2059), 1, + ACTIONS(2045), 1, anon_sym_EQ, STATE(742), 1, sym_block, - STATE(1264), 1, + STATE(1256), 1, sym_effect_set, - [54305] = 6, + [54215] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2061), 1, + ACTIONS(2047), 1, anon_sym_EQ, STATE(743), 1, sym_block, - STATE(1265), 1, + STATE(1258), 1, sym_effect_set, - [54324] = 6, + [54234] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(2063), 1, + ACTIONS(2049), 1, anon_sym_EQ, - STATE(747), 1, + STATE(689), 1, sym_block, - STATE(1122), 1, + STATE(1116), 1, sym_effect_set, - [54343] = 6, + [54253] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2065), 1, + ACTIONS(2051), 1, anon_sym_EQ, - STATE(1143), 1, + STATE(1136), 1, sym_effect_set, - STATE(1713), 1, + STATE(1731), 1, sym_block, - [54362] = 4, + [54272] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2053), 1, + anon_sym_DOT, + STATE(1248), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(2055), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [54287] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2067), 2, + ACTIONS(2057), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54377] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2069), 1, - anon_sym_RPAREN, - STATE(1108), 1, - sym_parameter, - STATE(1759), 1, - sym_parameter_list, - ACTIONS(2015), 2, - anon_sym__, - sym_identifier, - [54394] = 4, + [54302] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2071), 2, + ACTIONS(2059), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54409] = 4, + [54317] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2073), 2, + ACTIONS(2061), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54424] = 4, + [54332] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2075), 2, + ACTIONS(2063), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54439] = 5, + [54347] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, - sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1591), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [54456] = 6, - ACTIONS(3), 1, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2065), 1, + anon_sym_EQ, + STATE(1148), 1, + sym_effect_set, + STATE(1459), 1, + sym_block, + [54366] = 5, + ACTIONS(298), 1, sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(859), 1, - anon_sym_type, - STATE(227), 1, - aux_sym_doc_comment_repeat1, - STATE(749), 1, - sym_type_declaration, - STATE(1743), 1, - sym_doc_comment, - [54475] = 4, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + ACTIONS(2067), 1, + anon_sym_COLON, + STATE(1036), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1680), 2, + anon_sym_LBRACE, + anon_sym_PLUS, + [54383] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2077), 2, + ACTIONS(2069), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54490] = 5, + [54398] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2079), 1, + ACTIONS(2071), 1, anon_sym_PIPE, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1560), 1, + STATE(1553), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54507] = 5, + [54415] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2081), 1, + ACTIONS(2073), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1579), 1, + STATE(1572), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54524] = 4, + [54432] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2083), 1, - anon_sym_DOT, - STATE(1139), 1, - aux_sym_legacy_import_path_repeat1, - ACTIONS(2085), 3, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [54539] = 5, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, + sym_identifier, + STATE(1176), 1, + sym_type_arguments, + STATE(992), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54449] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(2075), 1, + anon_sym_RPAREN, + STATE(1073), 1, + sym_parameter, + STATE(1587), 1, + sym_parameter_list, + ACTIONS(2005), 2, + anon_sym__, + sym_identifier, + [54466] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(1182), 1, + STATE(1183), 1, sym_type_arguments, - STATE(997), 2, + STATE(1000), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54556] = 5, + [54483] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(2077), 1, + anon_sym_PIPE, + STATE(1073), 1, + sym_parameter, + STATE(1624), 1, + sym_parameter_list, + ACTIONS(2005), 2, + anon_sym__, + sym_identifier, + [54500] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(2087), 1, + ACTIONS(2079), 1, anon_sym_COLON, - STATE(1058), 1, + STATE(628), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1686), 2, + ACTIONS(1682), 2, anon_sym_LBRACE, anon_sym_PLUS, - [54573] = 4, + [54517] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2001), 1, sym_identifier, - ACTIONS(2089), 2, + STATE(1203), 1, + sym_type_parameter, + STATE(1580), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, anon_sym_in, - anon_sym_do, - STATE(1047), 2, + anon_sym_out, + [54534] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, + sym_identifier, + STATE(1126), 1, + sym_type_arguments, + STATE(1024), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54588] = 4, + [54551] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2009), 1, sym_identifier, - ACTIONS(2091), 2, + ACTIONS(2081), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54603] = 5, + [54566] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2093), 1, + ACTIONS(2083), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1594), 1, + STATE(1613), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54620] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, - sym_identifier, - STATE(1189), 1, - sym_type_arguments, - STATE(1001), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54637] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, - sym_identifier, - STATE(1160), 1, - sym_type_arguments, - STATE(1034), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [54654] = 5, + [54583] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2095), 1, + ACTIONS(2085), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1620), 1, + STATE(1500), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54671] = 5, + [54600] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2097), 1, + ACTIONS(2087), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1629), 1, + STATE(1622), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54688] = 4, + [54617] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2099), 1, + ACTIONS(2089), 1, sym_identifier, - ACTIONS(2102), 2, + ACTIONS(2092), 2, anon_sym_in, anon_sym_do, - STATE(1047), 2, + STATE(1043), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54703] = 5, + [54632] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2104), 1, + ACTIONS(2094), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1635), 1, + STATE(1628), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54720] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2106), 1, - anon_sym_EQ, - STATE(1152), 1, - sym_effect_set, - STATE(1578), 1, - sym_block, - [54739] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2011), 1, - sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1619), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [54756] = 5, + [54649] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2108), 1, + ACTIONS(2096), 1, anon_sym_PIPE, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1644), 1, + STATE(1637), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54773] = 5, + [54666] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2110), 1, + ACTIONS(2098), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1073), 1, sym_parameter, - STATE(1656), 1, + STATE(1649), 1, sym_parameter_list, - ACTIONS(2015), 2, + ACTIONS(2005), 2, anon_sym__, sym_identifier, - [54790] = 6, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1939), 1, - anon_sym_BANG, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2112), 1, - anon_sym_EQ, - STATE(1146), 1, - sym_effect_set, - STATE(1456), 1, - sym_block, - [54809] = 5, + [54683] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(1228), 1, + STATE(1222), 1, sym_type_arguments, - STATE(1027), 2, + STATE(1023), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54826] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2011), 1, - sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1744), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [54843] = 5, + [54700] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(1875), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(1825), 1, sym_identifier, - STATE(1232), 1, + STATE(1226), 1, sym_type_arguments, - STATE(1029), 2, + STATE(1025), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [54860] = 6, + [54717] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1939), 1, + ACTIONS(1929), 1, anon_sym_BANG, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2114), 1, + ACTIONS(2100), 1, anon_sym_EQ, - STATE(1167), 1, + STATE(1122), 1, sym_effect_set, - STATE(1593), 1, + STATE(1584), 1, sym_block, - [54879] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1752), 1, - anon_sym_COLON_COLON, - ACTIONS(2116), 1, - anon_sym_COLON, - STATE(764), 1, - aux_sym_qualified_path_repeat1, - ACTIONS(1688), 2, - anon_sym_LBRACE, - anon_sym_PLUS, - [54896] = 5, + [54736] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1596), 1, + STATE(1733), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [54913] = 5, + [54753] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2009), 1, + sym_identifier, + ACTIONS(2102), 2, + anon_sym_in, + anon_sym_do, + STATE(1043), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54768] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1621), 1, + STATE(1589), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [54930] = 6, + [54785] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, - anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2118), 1, + ACTIONS(2001), 1, + sym_identifier, + STATE(1203), 1, + sym_type_parameter, + STATE(1614), 1, + sym_type_parameter_list, + ACTIONS(2003), 2, + anon_sym_in, + anon_sym_out, + [54802] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(71), 1, + sym__doc_comment_line, + ACTIONS(859), 1, + anon_sym_type, + STATE(227), 1, + aux_sym_doc_comment_repeat1, + STATE(710), 1, + sym_type_declaration, + STATE(1742), 1, + sym_doc_comment, + [54821] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_BANG, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2104), 1, + anon_sym_EQ, + STATE(1144), 1, + sym_effect_set, + STATE(1599), 1, + sym_block, + [54840] = 6, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1301), 1, + anon_sym_COLON_COLON, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2106), 1, anon_sym_DOT, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1735), 1, + STATE(1728), 1, sym_type_arguments, - [54949] = 6, + [54859] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2120), 1, + ACTIONS(2108), 1, sym_identifier, - ACTIONS(2122), 1, + ACTIONS(2110), 1, sym_string, - STATE(1082), 1, + STATE(1087), 1, sym_import_target, - STATE(1099), 1, + STATE(1110), 1, sym_namespace_name, - STATE(1660), 1, + STATE(1727), 1, sym_legacy_import_path, - [54968] = 5, + [54878] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1708), 1, + STATE(1701), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [54985] = 5, + [54895] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1709), 1, + STATE(1702), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [55002] = 5, + [54912] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1711), 1, + STATE(1704), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [55019] = 6, + [54929] = 6, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1752), 1, + ACTIONS(1301), 1, anon_sym_COLON_COLON, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2124), 1, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2112), 1, anon_sym_DOT, - STATE(827), 1, + STATE(641), 1, aux_sym_qualified_path_repeat1, - STATE(1746), 1, + STATE(1739), 1, sym_type_arguments, - [55038] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(71), 1, - sym__doc_comment_line, - ACTIONS(859), 1, - anon_sym_type, - STATE(227), 1, - aux_sym_doc_comment_repeat1, - STATE(711), 1, - sym_type_declaration, - STATE(1743), 1, - sym_doc_comment, - [55057] = 5, + [54948] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1737), 1, + STATE(1668), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [55074] = 5, + [54965] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2001), 1, sym_identifier, - STATE(1191), 1, + STATE(1203), 1, sym_type_parameter, - STATE(1740), 1, + STATE(1730), 1, sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2003), 2, anon_sym_in, anon_sym_out, - [55091] = 5, + [54982] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2009), 1, sym_identifier, - STATE(1191), 1, - sym_type_parameter, - STATE(1395), 1, - sym_type_parameter_list, - ACTIONS(2013), 2, + ACTIONS(2114), 2, anon_sym_in, - anon_sym_out, - [55108] = 2, + anon_sym_do, + STATE(1043), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [54997] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2126), 4, + ACTIONS(2116), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55118] = 4, + [55007] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2128), 1, - anon_sym_PIPE, - STATE(1113), 1, - aux_sym_union_type_repeat1, - ACTIONS(1332), 2, - sym__statement_break, - anon_sym_where, - [55132] = 2, + ACTIONS(2118), 1, + anon_sym_COMMA, + STATE(1066), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2121), 2, + anon_sym_GT, + anon_sym_RPAREN, + [55021] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2130), 4, + ACTIONS(566), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55142] = 4, + [55031] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2132), 1, + ACTIONS(2123), 1, sym_identifier, - ACTIONS(2135), 1, - anon_sym_in, - STATE(1074), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55156] = 2, + ACTIONS(2125), 1, + anon_sym_RPAREN, + STATE(1131), 1, + sym_extern_parameter, + STATE(1455), 1, + sym_extern_parameter_list, + [55047] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2137), 4, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55166] = 2, + ACTIONS(2127), 1, + anon_sym_PIPE, + STATE(1106), 1, + aux_sym_union_type_repeat1, + ACTIONS(1342), 2, + sym__statement_break, + anon_sym_where, + [55061] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2139), 4, + ACTIONS(2131), 1, + anon_sym_COLON, + ACTIONS(2129), 3, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55176] = 2, + anon_sym_PIPE, + [55073] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2141), 4, + ACTIONS(2133), 1, anon_sym_COMMA, + STATE(1071), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1050), 2, anon_sym_RPAREN, anon_sym_RBRACK, - anon_sym_EQ_GT, - [55186] = 2, + [55087] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2143), 4, + ACTIONS(2136), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55196] = 2, + [55097] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2145), 4, + ACTIONS(2138), 1, anon_sym_COMMA, + STATE(1083), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2140), 2, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [55206] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2147), 1, - sym_identifier, - STATE(978), 1, - sym_qualified_path, - STATE(1194), 1, - sym_effect_ref, - STATE(1482), 1, - sym_effect_list, - [55222] = 4, + anon_sym_PIPE, + [55111] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2149), 1, + ACTIONS(2142), 1, anon_sym_COLON_COLON, - STATE(1115), 1, + STATE(1101), 1, aux_sym_import_target_repeat1, - ACTIONS(2152), 2, + ACTIONS(2145), 2, sym__statement_break, anon_sym_as, - [55236] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2154), 1, - anon_sym_COLON_COLON, - ACTIONS(2156), 1, - anon_sym_as, - ACTIONS(2158), 1, - sym__statement_break, - STATE(1727), 1, - sym_import_tail, - [55252] = 2, + [55125] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2160), 4, + ACTIONS(2147), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55262] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2147), 1, - sym_identifier, - STATE(978), 1, - sym_qualified_path, - STATE(1194), 1, - sym_effect_ref, - STATE(1450), 1, - sym_effect_list, - [55278] = 2, + [55135] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1809), 4, - anon_sym_LBRACE, + ACTIONS(2149), 4, anon_sym_COMMA, - anon_sym_EQ, + anon_sym_RPAREN, anon_sym_RBRACK, - [55288] = 5, + anon_sym_EQ_GT, + [55145] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2162), 1, - sym_identifier, - ACTIONS(2164), 1, + ACTIONS(2151), 1, + anon_sym_PIPE, + STATE(1077), 1, + aux_sym_union_type_repeat1, + ACTIONS(1337), 2, + sym__statement_break, + anon_sym_where, + [55159] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1780), 1, + anon_sym_LT, + ACTIONS(1784), 1, anon_sym_LBRACK, - STATE(807), 1, - sym_qualified_path, - STATE(886), 1, - sym_effect_ref, - [55304] = 2, + ACTIONS(979), 2, + sym__statement_break, + anon_sym_where, + [55173] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2166), 4, + ACTIONS(2154), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55314] = 4, + [55183] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2168), 1, - anon_sym_COMMA, - STATE(1088), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1050), 2, - anon_sym_RPAREN, - anon_sym_RBRACK, - [55328] = 4, + ACTIONS(2001), 1, + sym_identifier, + STATE(1323), 1, + sym_type_parameter, + ACTIONS(2003), 2, + anon_sym_in, + anon_sym_out, + [55197] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2171), 1, + ACTIONS(2156), 1, sym_identifier, - ACTIONS(2173), 1, + ACTIONS(2158), 1, anon_sym_in, - STATE(1074), 2, + STATE(1109), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [55342] = 5, + [55211] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2175), 1, + ACTIONS(2160), 1, sym_identifier, - ACTIONS(2177), 1, + ACTIONS(2162), 1, anon_sym_EQ_GT, - STATE(1175), 1, + STATE(1187), 1, aux_sym_handler_params_repeat1, - STATE(1751), 1, + STATE(1374), 1, sym_handler_params, - [55358] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2179), 1, - anon_sym_COMMA, - STATE(1101), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2181), 2, - anon_sym_GT, - anon_sym_RPAREN, - [55372] = 4, + [55227] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2183), 1, + ACTIONS(2138), 1, anon_sym_COMMA, - STATE(1092), 1, + STATE(1111), 1, aux_sym_parameter_list_repeat1, - ACTIONS(2186), 2, + ACTIONS(2164), 2, anon_sym_RPAREN, anon_sym_PIPE, - [55386] = 4, + [55241] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2188), 1, - anon_sym_COMMA, - STATE(1092), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2190), 2, - anon_sym_RPAREN, - anon_sym_PIPE, - [55400] = 3, + ACTIONS(2156), 1, + sym_identifier, + ACTIONS(2166), 1, + anon_sym_in, + STATE(1109), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55255] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2194), 1, - anon_sym_COLON, - ACTIONS(2192), 3, + ACTIONS(2168), 1, + sym_identifier, + STATE(984), 1, + sym_qualified_path, + STATE(1212), 1, + sym_effect_ref, + STATE(1445), 1, + sym_effect_list, + [55271] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2170), 1, anon_sym_COMMA, + STATE(1093), 1, + aux_sym_positional_payload_repeat1, + ACTIONS(2172), 2, + anon_sym_GT, anon_sym_RPAREN, - anon_sym_PIPE, - [55412] = 4, + [55285] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1827), 1, - anon_sym_LT, - ACTIONS(1831), 1, - anon_sym_LBRACK, - ACTIONS(979), 2, + ACTIONS(2174), 1, + anon_sym_COLON_COLON, + ACTIONS(2176), 1, + anon_sym_as, + ACTIONS(2178), 1, sym__statement_break, - anon_sym_where, - [55426] = 5, + STATE(1375), 1, + sym_import_tail, + [55301] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, + ACTIONS(2180), 1, sym_identifier, - ACTIONS(2198), 1, - anon_sym_RPAREN, - STATE(1144), 1, - sym_extern_parameter, - STATE(1388), 1, - sym_extern_parameter_list, - [55442] = 4, + ACTIONS(2182), 1, + anon_sym_LBRACK, + STATE(818), 1, + sym_qualified_path, + STATE(876), 1, + sym_effect_ref, + [55317] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2168), 1, sym_identifier, - STATE(1325), 1, - sym_type_parameter, - ACTIONS(2013), 2, - anon_sym_in, - anon_sym_out, - [55456] = 2, + STATE(984), 1, + sym_qualified_path, + STATE(1212), 1, + sym_effect_ref, + STATE(1512), 1, + sym_effect_list, + [55333] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2200), 4, + ACTIONS(2184), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55466] = 4, + [55343] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2202), 1, - anon_sym_COLON_COLON, - STATE(1081), 1, - aux_sym_import_target_repeat1, - ACTIONS(2205), 2, - sym__statement_break, - anon_sym_as, - [55480] = 4, + ACTIONS(2186), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55353] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2171), 1, - sym_identifier, - ACTIONS(2207), 1, - anon_sym_in, - STATE(1074), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55494] = 4, + ACTIONS(2188), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55363] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2170), 1, anon_sym_COMMA, - STATE(1114), 1, + STATE(1066), 1, aux_sym_positional_payload_repeat1, - ACTIONS(2209), 2, + ACTIONS(2190), 2, anon_sym_GT, anon_sym_RPAREN, - [55508] = 5, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2147), 1, - sym_identifier, - ACTIONS(2211), 1, - anon_sym_LBRACK, - STATE(978), 1, - sym_qualified_path, - STATE(1329), 1, - sym_effect_ref, - [55524] = 5, + [55377] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, + ACTIONS(2123), 1, sym_identifier, - ACTIONS(2213), 1, + ACTIONS(2192), 1, anon_sym_RPAREN, - STATE(1144), 1, + STATE(1131), 1, sym_extern_parameter, - STATE(1430), 1, + STATE(1617), 1, sym_extern_parameter_list, - [55540] = 5, + [55393] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, + ACTIONS(2160), 1, + sym_identifier, + ACTIONS(2194), 1, + anon_sym_EQ_GT, + STATE(1187), 1, + aux_sym_handler_params_repeat1, + STATE(1392), 1, + sym_handler_params, + [55409] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2123), 1, sym_identifier, - ACTIONS(2215), 1, + ACTIONS(2196), 1, anon_sym_RPAREN, - STATE(1144), 1, + STATE(1131), 1, sym_extern_parameter, - STATE(1442), 1, + STATE(1396), 1, sym_extern_parameter_list, - [55556] = 2, + [55425] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2217), 4, + ACTIONS(1766), 4, + anon_sym_LBRACE, anon_sym_COMMA, - anon_sym_RPAREN, + anon_sym_EQ, anon_sym_RBRACK, - anon_sym_EQ_GT, - [55566] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2171), 1, - sym_identifier, - ACTIONS(2219), 1, - anon_sym_in, - STATE(1074), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [55580] = 2, + [55435] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2221), 4, + ACTIONS(2198), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55590] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2188), 1, - anon_sym_COMMA, - STATE(1093), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(2223), 2, - anon_sym_RPAREN, - anon_sym_PIPE, - [55604] = 5, + [55445] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2225), 1, + ACTIONS(2200), 1, sym_identifier, - ACTIONS(2227), 1, + ACTIONS(2202), 1, anon_sym_RBRACE, - STATE(1166), 1, + STATE(1146), 1, sym_import_member, - STATE(1712), 1, + STATE(1720), 1, sym_import_member_list, - [55620] = 5, + [55461] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, + ACTIONS(2168), 1, + sym_identifier, + ACTIONS(2204), 1, + anon_sym_LBRACK, + STATE(984), 1, + sym_qualified_path, + STATE(1329), 1, + sym_effect_ref, + [55477] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2206), 1, + anon_sym_COLON_COLON, + STATE(1101), 1, + aux_sym_import_target_repeat1, + ACTIONS(2209), 2, + sym__statement_break, + anon_sym_as, + [55491] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2156), 1, + sym_identifier, + ACTIONS(2211), 1, + anon_sym_in, + STATE(1109), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55505] = 5, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2123), 1, sym_identifier, - ACTIONS(2229), 1, + ACTIONS(2213), 1, anon_sym_RPAREN, - STATE(1144), 1, + STATE(1131), 1, sym_extern_parameter, - STATE(1401), 1, + STATE(1437), 1, sym_extern_parameter_list, - [55636] = 2, + [55521] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2231), 4, + ACTIONS(2215), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55646] = 5, + [55531] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, - sym_identifier, - ACTIONS(2233), 1, + ACTIONS(2217), 4, + anon_sym_COMMA, anon_sym_RPAREN, - STATE(1144), 1, - sym_extern_parameter, - STATE(1606), 1, - sym_extern_parameter_list, - [55662] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55541] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2128), 1, + ACTIONS(2127), 1, anon_sym_PIPE, - STATE(1116), 1, + STATE(1077), 1, aux_sym_union_type_repeat1, - ACTIONS(1336), 2, + ACTIONS(1346), 2, sym__statement_break, anon_sym_where, - [55676] = 4, + [55555] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2235), 1, + ACTIONS(2219), 4, anon_sym_COMMA, - STATE(1114), 1, - aux_sym_positional_payload_repeat1, - ACTIONS(2238), 2, - anon_sym_GT, anon_sym_RPAREN, - [55690] = 4, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [55565] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2240), 1, + ACTIONS(2123), 1, + sym_identifier, + ACTIONS(2221), 1, + anon_sym_RPAREN, + STATE(1131), 1, + sym_extern_parameter, + STATE(1395), 1, + sym_extern_parameter_list, + [55581] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2223), 1, + sym_identifier, + ACTIONS(2226), 1, + anon_sym_in, + STATE(1109), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [55595] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2228), 1, anon_sym_COLON_COLON, - STATE(1115), 1, + STATE(1074), 1, aux_sym_import_target_repeat1, - ACTIONS(2243), 2, + ACTIONS(2231), 2, sym__statement_break, anon_sym_as, - [55704] = 4, + [55609] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2245), 1, + ACTIONS(2233), 1, + anon_sym_COMMA, + STATE(1111), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2236), 2, + anon_sym_RPAREN, anon_sym_PIPE, - STATE(1116), 1, - aux_sym_union_type_repeat1, - ACTIONS(1338), 2, - sym__statement_break, - anon_sym_where, - [55718] = 2, + [55623] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(566), 4, + ACTIONS(2238), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55728] = 5, + [55633] = 5, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2175), 1, + ACTIONS(2123), 1, sym_identifier, - ACTIONS(2248), 1, - anon_sym_EQ_GT, - STATE(1175), 1, - aux_sym_handler_params_repeat1, - STATE(1393), 1, - sym_handler_params, - [55744] = 2, + ACTIONS(2240), 1, + anon_sym_RPAREN, + STATE(1131), 1, + sym_extern_parameter, + STATE(1372), 1, + sym_extern_parameter_list, + [55649] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2250), 4, + ACTIONS(2242), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [55754] = 5, + [55659] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2196), 1, - sym_identifier, + ACTIONS(2244), 1, + anon_sym_LBRACE, + ACTIONS(2246), 1, + anon_sym_COLON, + STATE(1469), 1, + sym_signature_ascription, + [55672] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(2248), 1, + anon_sym_EQ, + STATE(748), 1, + sym_block, + [55685] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2250), 1, + anon_sym_COMMA, ACTIONS(2252), 1, - anon_sym_RPAREN, - STATE(1144), 1, - sym_extern_parameter, - STATE(1701), 1, - sym_extern_parameter_list, - [55770] = 4, + anon_sym_GT, + STATE(1188), 1, + aux_sym_type_parameter_list_repeat1, + [55698] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(2254), 1, anon_sym_RBRACE, ACTIONS(2256), 1, anon_sym_COMMA, - STATE(1200), 1, - aux_sym_field_declarations_repeat1, - [55783] = 4, + STATE(1252), 1, + aux_sym_field_assignments_repeat1, + [55711] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, ACTIONS(2258), 1, + anon_sym_COMMA, + ACTIONS(2260), 1, + anon_sym_GT, + STATE(1245), 1, + aux_sym__call_type_list_repeat1, + [55724] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2055), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [55733] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2256), 1, + anon_sym_COMMA, + ACTIONS(2262), 1, + anon_sym_RBRACE, + STATE(1118), 1, + aux_sym_field_assignments_repeat1, + [55746] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2264), 1, anon_sym_EQ, - STATE(748), 1, + STATE(1640), 1, sym_block, - [55796] = 4, + [55759] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2266), 1, + anon_sym_RBRACE, + ACTIONS(2268), 1, + anon_sym_COMMA, + STATE(1130), 1, + aux_sym_map_literal_repeat1, + [55772] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2260), 1, + ACTIONS(2270), 1, anon_sym_EQ, - STATE(1703), 1, + STATE(1559), 1, sym_block, + [55785] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2272), 1, + sym_identifier, + STATE(1121), 1, + sym_field_assignment, + STATE(1531), 1, + sym_field_assignments, + [55798] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1825), 1, + sym_identifier, + STATE(1029), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, [55809] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2262), 1, - anon_sym_RBRACE, - ACTIONS(2264), 1, - anon_sym_COMMA, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2274), 1, + anon_sym_EQ, + STATE(1671), 1, + sym_block, [55822] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(886), 1, + ACTIONS(2276), 1, anon_sym_COMMA, - ACTIONS(1764), 1, - anon_sym_RBRACE, - STATE(1218), 1, - aux_sym_field_pattern_repeat1, + ACTIONS(2279), 1, + anon_sym_RBRACK, + STATE(1128), 1, + aux_sym_list_pattern_repeat1, [55835] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2267), 1, - sym_identifier, - STATE(644), 1, - sym_qualified_path, - STATE(650), 1, - sym_variant, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2281), 1, + anon_sym_EQ, + STATE(1524), 1, + sym_block, [55848] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1364), 1, - sym__statement_break, - ACTIONS(2269), 1, - anon_sym_where, - STATE(1460), 1, - sym_type_validation, + ACTIONS(2268), 1, + anon_sym_COMMA, + ACTIONS(2283), 1, + anon_sym_RBRACE, + STATE(1261), 1, + aux_sym_map_literal_repeat1, [55861] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2271), 1, + ACTIONS(2285), 1, anon_sym_COMMA, - ACTIONS(2273), 1, - anon_sym_GT, - STATE(1266), 1, - aux_sym_type_parameter_list_repeat1, + ACTIONS(2287), 1, + anon_sym_RPAREN, + STATE(1231), 1, + aux_sym_extern_parameter_list_repeat1, [55874] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2275), 1, - anon_sym_RBRACE, - ACTIONS(2277), 1, + ACTIONS(988), 1, anon_sym_COMMA, - STATE(1136), 1, - aux_sym_map_literal_repeat1, + ACTIONS(2289), 1, + anon_sym_RBRACK, + STATE(1071), 1, + aux_sym_argument_list_repeat1, [55887] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2053), 1, - anon_sym_DOT, - STATE(1608), 1, - sym_type_arguments, + ACTIONS(2291), 1, + anon_sym_RBRACE, + ACTIONS(2293), 1, + anon_sym_COMMA, + STATE(1198), 1, + aux_sym_field_declarations_repeat1, [55900] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2279), 1, - anon_sym_RBRACE, - ACTIONS(2281), 1, - anon_sym_COMMA, - STATE(1145), 1, - aux_sym_field_assignments_repeat1, + ACTIONS(2272), 1, + sym_identifier, + STATE(1121), 1, + sym_field_assignment, + STATE(1560), 1, + sym_field_assignments, [55913] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2281), 1, - anon_sym_COMMA, - ACTIONS(2283), 1, - anon_sym_RBRACE, - STATE(1131), 1, - aux_sym_field_assignments_repeat1, + ACTIONS(2295), 1, + sym_identifier, + STATE(1133), 1, + sym_field_declaration, + STATE(1594), 1, + sym_field_declarations, [55926] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(988), 1, - anon_sym_COMMA, - ACTIONS(2285), 1, - anon_sym_RBRACK, - STATE(1088), 1, - aux_sym_argument_list_repeat1, - [55939] = 4, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2297), 1, + anon_sym_EQ, + STATE(1743), 1, + sym_block, + [55939] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2287), 1, + ACTIONS(2299), 1, + anon_sym_as, + ACTIONS(2301), 2, + anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(2290), 1, - anon_sym_RBRACK, - STATE(1134), 1, - aux_sym_list_pattern_repeat1, - [55952] = 4, + [55950] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2147), 1, + ACTIONS(2303), 1, sym_identifier, - STATE(978), 1, + STATE(998), 1, sym_qualified_path, - STATE(1324), 1, - sym_effect_ref, - [55965] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2277), 1, - anon_sym_COMMA, - ACTIONS(2292), 1, - anon_sym_RBRACE, - STATE(1156), 1, - aux_sym_map_literal_repeat1, - [55978] = 4, + STATE(1158), 1, + sym_variant, + [55963] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2294), 1, - anon_sym_COMMA, - ACTIONS(2296), 1, - anon_sym_RBRACK, - STATE(1263), 1, - aux_sym_effect_list_repeat1, - [55991] = 4, + ACTIONS(1362), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [55972] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(988), 1, - anon_sym_COMMA, - ACTIONS(2298), 1, - anon_sym_RBRACK, - STATE(1088), 1, - aux_sym_argument_list_repeat1, - [56004] = 4, + STATE(1200), 1, + sym_namespace_name, + ACTIONS(2305), 2, + sym_string, + sym_identifier, + [55983] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2083), 1, - anon_sym_DOT, - ACTIONS(2300), 1, + ACTIONS(1360), 3, sym__statement_break, - STATE(1248), 1, - aux_sym_legacy_import_path_repeat1, - [56017] = 4, + anon_sym_PIPE, + anon_sym_where, + [55992] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2302), 1, - anon_sym_RBRACE, - ACTIONS(2304), 1, - anon_sym_COMMA, - STATE(1140), 1, - aux_sym_field_declarations_repeat1, - [56030] = 4, + ACTIONS(2168), 1, + sym_identifier, + STATE(984), 1, + sym_qualified_path, + STATE(1324), 1, + sym_effect_ref, + [56005] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, ACTIONS(2307), 1, - anon_sym_EQ, - STATE(1557), 1, - sym_block, - [56043] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1354), 1, - sym__statement_break, - ACTIONS(2269), 1, - anon_sym_where, - STATE(1374), 1, - sym_type_validation, - [56056] = 4, + anon_sym_COMMA, + ACTIONS(2309), 1, + anon_sym_RBRACK, + STATE(1195), 1, + aux_sym_effect_list_repeat1, + [56018] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2309), 1, + ACTIONS(2311), 1, anon_sym_EQ, - STATE(1738), 1, + STATE(1644), 1, sym_block, - [56069] = 4, + [56031] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2311), 1, + ACTIONS(2170), 1, anon_sym_COMMA, ACTIONS(2313), 1, anon_sym_RPAREN, - STATE(1161), 1, - aux_sym_extern_parameter_list_repeat1, - [56082] = 4, + STATE(1066), 1, + aux_sym_positional_payload_repeat1, + [56044] = 4, ACTIONS(298), 1, sym_line_comment, ACTIONS(2315), 1, anon_sym_RBRACE, ACTIONS(2317), 1, anon_sym_COMMA, - STATE(1145), 1, - aux_sym_field_assignments_repeat1, - [56095] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2320), 1, - anon_sym_EQ, - STATE(1531), 1, - sym_block, - [56108] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2322), 1, - anon_sym_EQ, - STATE(1663), 1, - sym_block, - [56121] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2324), 1, - sym_identifier, - STATE(1121), 1, - sym_field_declaration, - STATE(1595), 1, - sym_field_declarations, - [56134] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2326), 1, - sym_identifier, - STATE(1132), 1, - sym_field_assignment, - STATE(1523), 1, - sym_field_assignments, - [56147] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2328), 1, - anon_sym_COMMA, - ACTIONS(2330), 1, - anon_sym_GT, - STATE(1181), 1, - aux_sym__call_type_list_repeat1, - [56160] = 2, + STATE(1184), 1, + aux_sym_import_member_list_repeat1, + [56057] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2332), 3, + ACTIONS(2268), 1, anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_PIPE, - [56169] = 4, + ACTIONS(2319), 1, + anon_sym_RBRACE, + STATE(1155), 1, + aux_sym_map_literal_repeat1, + [56070] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2334), 1, + ACTIONS(2321), 1, anon_sym_EQ, - STATE(1637), 1, + STATE(1543), 1, sym_block, - [56182] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2336), 1, - sym_identifier, - STATE(1009), 1, - sym_qualified_path, - STATE(1202), 1, - sym_variant, - [56195] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2338), 1, - anon_sym_COMMA, - ACTIONS(2340), 1, - anon_sym_RPAREN, - STATE(1242), 1, - aux_sym_pattern_repeat1, - [56208] = 4, + [56083] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2342), 1, + ACTIONS(2323), 1, anon_sym_LBRACE, - ACTIONS(2344), 1, + ACTIONS(2325), 1, anon_sym_if, STATE(381), 1, sym_if_expression, - [56221] = 4, + [56096] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2346), 1, - anon_sym_RBRACE, - ACTIONS(2348), 1, + ACTIONS(2327), 1, anon_sym_COMMA, - STATE(1156), 1, - aux_sym_map_literal_repeat1, - [56234] = 4, + ACTIONS(2330), 1, + anon_sym_RPAREN, + STATE(1150), 1, + aux_sym_pattern_repeat1, + [56109] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(988), 1, + ACTIONS(2121), 3, anon_sym_COMMA, - ACTIONS(2351), 1, + anon_sym_GT, anon_sym_RPAREN, - STATE(1088), 1, - aux_sym_argument_list_repeat1, - [56247] = 4, + [56118] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2353), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2355), 1, - anon_sym_COLON, - STATE(1494), 1, - sym_signature_ascription, - [56260] = 4, + ACTIONS(2332), 1, + anon_sym_EQ, + STATE(1418), 1, + sym_block, + [56131] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, - sym_identifier, - STATE(1132), 1, - sym_field_assignment, - STATE(1555), 1, - sym_field_assignments, - [56273] = 3, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2029), 1, + anon_sym_DOT, + STATE(1663), 1, + sym_type_arguments, + [56144] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, + ACTIONS(2334), 1, sym_identifier, - STATE(1040), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [56284] = 4, + STATE(1084), 2, + sym_kernel_arm, + aux_sym_kernel_expression_repeat1, + [56155] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2311), 1, + ACTIONS(2268), 1, anon_sym_COMMA, - ACTIONS(2357), 1, - anon_sym_RPAREN, - STATE(1236), 1, - aux_sym_extern_parameter_list_repeat1, - [56297] = 3, + ACTIONS(2336), 1, + anon_sym_RBRACE, + STATE(1261), 1, + aux_sym_map_literal_repeat1, + [56168] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1190), 1, - sym_parameter, - ACTIONS(2015), 2, - anon_sym__, - sym_identifier, - [56308] = 4, + ACTIONS(2246), 1, + anon_sym_COLON, + ACTIONS(2338), 1, + anon_sym_LBRACE, + STATE(1750), 1, + sym_signature_ascription, + [56181] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2328), 1, - anon_sym_COMMA, - ACTIONS(2359), 1, - anon_sym_GT, - STATE(1181), 1, - aux_sym__call_type_list_repeat1, - [56321] = 3, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2340), 1, + anon_sym_EQ, + STATE(1705), 1, + sym_block, + [56194] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2361), 1, - anon_sym_as, - ACTIONS(2363), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [56332] = 3, + ACTIONS(1337), 3, + sym__statement_break, + anon_sym_PIPE, + anon_sym_where, + [56203] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2365), 1, + ACTIONS(2334), 1, sym_identifier, - STATE(1106), 2, + STATE(1081), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [56343] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2367), 1, - anon_sym_RBRACE, - ACTIONS(2369), 1, - anon_sym_COMMA, - STATE(1243), 1, - aux_sym_import_member_list_repeat1, - [56356] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2371), 1, - anon_sym_EQ, - STATE(1641), 1, - sym_block, - [56369] = 4, + [56214] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2373), 1, - anon_sym_RBRACE, - ACTIONS(2375), 1, - anon_sym_COMMA, - STATE(1168), 1, - aux_sym_import_member_list_repeat1, - [56382] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2378), 1, + ACTIONS(2342), 1, anon_sym_EQ, STATE(698), 1, sym_block, - [56395] = 2, + [56227] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1343), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [56404] = 4, + ACTIONS(2272), 1, + sym_identifier, + STATE(1121), 1, + sym_field_assignment, + STATE(1379), 1, + sym_field_assignments, + [56240] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2277), 1, + ACTIONS(886), 1, anon_sym_COMMA, - ACTIONS(2380), 1, + ACTIONS(2344), 1, anon_sym_RBRACE, - STATE(1156), 1, - aux_sym_map_literal_repeat1, - [56417] = 2, + STATE(1172), 1, + aux_sym_field_pattern_repeat1, + [56253] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1358), 3, + ACTIONS(1364), 1, sym__statement_break, - anon_sym_PIPE, + ACTIONS(2346), 1, anon_sym_where, - [56426] = 4, + STATE(1463), 1, + sym_type_validation, + [56266] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, - anon_sym_COLON, - ACTIONS(2382), 1, - anon_sym_LBRACE, - STATE(1587), 1, - sym_signature_ascription, - [56439] = 4, + ACTIONS(2348), 1, + anon_sym_COMMA, + ACTIONS(2350), 1, + anon_sym_RPAREN, + STATE(1150), 1, + aux_sym_pattern_repeat1, + [56279] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, - sym_identifier, - STATE(1132), 1, - sym_field_assignment, - STATE(1755), 1, - sym_field_assignments, - [56452] = 4, + ACTIONS(2352), 1, + anon_sym_LBRACE, + ACTIONS(2354), 1, + anon_sym_if, + STATE(285), 1, + sym_if_expression, + [56292] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2384), 1, + ACTIONS(2356), 1, sym_identifier, - ACTIONS(2386), 1, + ACTIONS(2359), 1, anon_sym_EQ_GT, - STATE(1213), 1, + STATE(1166), 1, aux_sym_handler_params_repeat1, - [56465] = 4, + [56305] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, + ACTIONS(2246), 1, anon_sym_COLON, - ACTIONS(2388), 1, + ACTIONS(2361), 1, anon_sym_LBRACE, - STATE(1688), 1, + STATE(1753), 1, sym_signature_ascription, - [56478] = 4, + [56318] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1132), 1, + STATE(1121), 1, sym_field_assignment, - STATE(1373), 1, + STATE(1748), 1, sym_field_assignments, - [56491] = 4, + [56331] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2390), 1, - anon_sym_LBRACE, - ACTIONS(2392), 1, - anon_sym_if, - STATE(285), 1, - sym_if_expression, - [56504] = 4, + ACTIONS(886), 1, + anon_sym_COMMA, + ACTIONS(1762), 1, + anon_sym_RBRACE, + STATE(1162), 1, + aux_sym_field_pattern_repeat1, + [56344] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, - ACTIONS(2394), 1, - anon_sym_EQ, - STATE(1674), 1, - sym_block, - [56517] = 2, + ACTIONS(988), 1, + anon_sym_COMMA, + ACTIONS(2363), 1, + anon_sym_RBRACK, + STATE(1071), 1, + aux_sym_argument_list_repeat1, + [56357] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2085), 3, + ACTIONS(2272), 1, + sym_identifier, + STATE(1121), 1, + sym_field_assignment, + STATE(1368), 1, + sym_field_assignments, + [56370] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2365), 1, + anon_sym_RBRACE, + ACTIONS(2367), 1, + anon_sym_COMMA, + STATE(1172), 1, + aux_sym_field_pattern_repeat1, + [56383] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1352), 1, sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [56526] = 4, + ACTIONS(2346), 1, + anon_sym_where, + STATE(1380), 1, + sym_type_validation, + [56396] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2396), 1, + ACTIONS(2370), 1, anon_sym_COMMA, - ACTIONS(2399), 1, - anon_sym_GT, - STATE(1181), 1, - aux_sym__call_type_list_repeat1, - [56539] = 3, + ACTIONS(2372), 1, + anon_sym_RPAREN, + STATE(1186), 1, + aux_sym_named_argument_list_repeat1, + [56409] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(2374), 1, + anon_sym_EQ, + STATE(702), 1, + sym_block, + [56422] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, + ACTIONS(1825), 1, sym_identifier, - STATE(1002), 2, + STATE(1001), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [56550] = 4, + [56433] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, + ACTIONS(2246), 1, anon_sym_COLON, - ACTIONS(2401), 1, + ACTIONS(2376), 1, anon_sym_LBRACE, - STATE(1600), 1, + STATE(1593), 1, sym_signature_ascription, - [56563] = 3, + [56446] = 4, ACTIONS(298), 1, sym_line_comment, - STATE(1238), 1, - sym_namespace_name, - ACTIONS(2403), 2, - sym_string, - sym_identifier, - [56574] = 4, + ACTIONS(2268), 1, + anon_sym_COMMA, + ACTIONS(2378), 1, + anon_sym_RBRACE, + STATE(1216), 1, + aux_sym_map_literal_repeat1, + [56459] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1132), 1, + STATE(1121), 1, sym_field_assignment, - STATE(1390), 1, + STATE(1385), 1, sym_field_assignments, - [56587] = 4, + [56472] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, + ACTIONS(2246), 1, anon_sym_COLON, - ACTIONS(2405), 1, + ACTIONS(2380), 1, anon_sym_LBRACE, - STATE(1610), 1, + STATE(1603), 1, sym_signature_ascription, - [56600] = 4, + [56485] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2407), 1, - anon_sym_RBRACE, - ACTIONS(2409), 1, - anon_sym_COMMA, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, - [56613] = 4, + ACTIONS(2382), 1, + sym_identifier, + ACTIONS(2384), 1, + sym_static_stage, + STATE(1015), 1, + sym_qualified_path, + [56498] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2324), 1, + ACTIONS(2295), 1, sym_identifier, - STATE(1121), 1, + STATE(1133), 1, sym_field_declaration, - STATE(1402), 1, + STATE(1397), 1, sym_field_declarations, - [56626] = 3, + [56511] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, + ACTIONS(1825), 1, sym_identifier, STATE(1006), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [56637] = 2, + [56522] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2186), 3, + ACTIONS(2317), 1, anon_sym_COMMA, + ACTIONS(2386), 1, + anon_sym_RBRACE, + STATE(1192), 1, + aux_sym_import_member_list_repeat1, + [56535] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2388), 1, + anon_sym_COMMA, + ACTIONS(2390), 1, + anon_sym_RBRACK, + STATE(1218), 1, + aux_sym_list_pattern_repeat1, + [56548] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2392), 1, + anon_sym_COMMA, + ACTIONS(2395), 1, anon_sym_RPAREN, - anon_sym_PIPE, - [56646] = 4, + STATE(1186), 1, + aux_sym_named_argument_list_repeat1, + [56561] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2397), 1, + sym_identifier, + ACTIONS(2399), 1, + anon_sym_EQ_GT, + STATE(1166), 1, + aux_sym_handler_params_repeat1, + [56574] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2271), 1, + ACTIONS(2401), 1, anon_sym_COMMA, - ACTIONS(2412), 1, + ACTIONS(2404), 1, anon_sym_GT, - STATE(1128), 1, + STATE(1188), 1, aux_sym_type_parameter_list_repeat1, - [56659] = 4, + [56587] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2414), 1, + ACTIONS(2406), 1, anon_sym_EQ, - STATE(702), 1, + STATE(713), 1, sym_block, - [56672] = 4, + [56600] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2246), 1, + anon_sym_COLON, + ACTIONS(2408), 1, anon_sym_LBRACE, - ACTIONS(2416), 1, - anon_sym_EQ, - STATE(1448), 1, - sym_block, - [56685] = 4, + STATE(1615), 1, + sym_signature_ascription, + [56613] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2294), 1, - anon_sym_COMMA, - ACTIONS(2418), 1, - anon_sym_RBRACK, - STATE(1137), 1, - aux_sym_effect_list_repeat1, - [56698] = 4, + STATE(1211), 1, + sym_parameter, + ACTIONS(2005), 2, + anon_sym__, + sym_identifier, + [56624] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2420), 1, + ACTIONS(2410), 1, + anon_sym_RBRACE, + ACTIONS(2412), 1, anon_sym_COMMA, - ACTIONS(2423), 1, - anon_sym_RPAREN, - STATE(1195), 1, - aux_sym_named_argument_list_repeat1, - [56711] = 4, + STATE(1192), 1, + aux_sym_import_member_list_repeat1, + [56637] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, - anon_sym_COLON, - ACTIONS(2425), 1, - anon_sym_LBRACE, - STATE(1622), 1, - sym_signature_ascription, - [56724] = 4, + ACTIONS(2295), 1, + sym_identifier, + STATE(1133), 1, + sym_field_declaration, + STATE(1426), 1, + sym_field_declarations, + [56650] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2427), 1, + ACTIONS(2415), 1, anon_sym_EQ, - STATE(1522), 1, + STATE(1630), 1, sym_block, - [56737] = 4, + [56663] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, - anon_sym_COLON, - ACTIONS(2429), 1, - anon_sym_LBRACE, - STATE(1467), 1, - sym_signature_ascription, - [56750] = 4, + ACTIONS(2417), 1, + anon_sym_COMMA, + ACTIONS(2420), 1, + anon_sym_RBRACK, + STATE(1195), 1, + aux_sym_effect_list_repeat1, + [56676] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2324), 1, - sym_identifier, - STATE(1121), 1, - sym_field_declaration, - STATE(1431), 1, - sym_field_declarations, - [56763] = 4, + ACTIONS(2424), 1, + anon_sym_where, + ACTIONS(2422), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [56687] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2256), 1, + ACTIONS(2258), 1, + anon_sym_COMMA, + ACTIONS(2426), 1, + anon_sym_GT, + STATE(1233), 1, + aux_sym__call_type_list_repeat1, + [56700] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2293), 1, anon_sym_COMMA, - ACTIONS(2431), 1, + ACTIONS(2428), 1, anon_sym_RBRACE, - STATE(1140), 1, + STATE(1221), 1, aux_sym_field_declarations_repeat1, - [56776] = 4, + [56713] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2324), 1, + ACTIONS(2295), 1, sym_identifier, - STATE(1121), 1, + STATE(1133), 1, sym_field_declaration, - STATE(1548), 1, + STATE(1557), 1, sym_field_declarations, - [56789] = 2, + [56726] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1338), 3, - sym__statement_break, - anon_sym_PIPE, - anon_sym_where, - [56798] = 4, + ACTIONS(2430), 1, + anon_sym_LBRACE, + ACTIONS(2432), 1, + anon_sym_SEMI, + STATE(1636), 1, + sym_namespace_body, + [56739] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2433), 1, + ACTIONS(1923), 1, + anon_sym_LBRACE, + ACTIONS(2434), 1, + anon_sym_EQ, + STATE(720), 1, + sym_block, + [56752] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(988), 1, anon_sym_COMMA, ACTIONS(2436), 1, anon_sym_RPAREN, - STATE(1203), 1, - aux_sym_tuple_pattern_repeat1, - [56811] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2365), 1, - sym_identifier, - STATE(1089), 2, - sym_kernel_arm, - aux_sym_kernel_expression_repeat1, - [56822] = 4, + STATE(1071), 1, + aux_sym_argument_list_repeat1, + [56765] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, - anon_sym_LBRACE, + ACTIONS(2250), 1, + anon_sym_COMMA, ACTIONS(2438), 1, - anon_sym_EQ, - STATE(1571), 1, - sym_block, - [56835] = 4, + anon_sym_GT, + STATE(1117), 1, + aux_sym_type_parameter_list_repeat1, + [56778] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1360), 1, - sym__statement_break, - ACTIONS(2269), 1, - anon_sym_where, - STATE(1411), 1, - sym_type_validation, - [56848] = 4, + ACTIONS(1825), 1, + sym_identifier, + STATE(1039), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [56789] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, ACTIONS(2440), 1, anon_sym_EQ, - STATE(712), 1, + STATE(1453), 1, sym_block, - [56861] = 4, + [56802] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2179), 1, - anon_sym_COMMA, + ACTIONS(1931), 1, + anon_sym_LBRACE, ACTIONS(2442), 1, - anon_sym_RPAREN, - STATE(1211), 1, - aux_sym_positional_payload_repeat1, - [56874] = 4, + anon_sym_EQ, + STATE(1579), 1, + sym_block, + [56815] = 4, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2246), 1, + anon_sym_COLON, ACTIONS(2444), 1, - anon_sym_COMMA, - ACTIONS(2446), 1, - anon_sym_RBRACK, - STATE(1240), 1, - aux_sym_list_pattern_repeat1, - [56887] = 4, + anon_sym_LBRACE, + STATE(1688), 1, + sym_signature_ascription, + [56828] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2277), 1, - anon_sym_COMMA, + ACTIONS(2446), 1, + anon_sym_LBRACE, ACTIONS(2448), 1, - anon_sym_RBRACE, - STATE(1245), 1, - aux_sym_map_literal_repeat1, - [56900] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2179), 1, - anon_sym_COMMA, - ACTIONS(2450), 1, - anon_sym_RPAREN, - STATE(1114), 1, - aux_sym_positional_payload_repeat1, - [56913] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1362), 1, - sym__statement_break, - ACTIONS(2269), 1, - anon_sym_where, - STATE(1584), 1, - sym_type_validation, - [56926] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2452), 1, - sym_identifier, - ACTIONS(2455), 1, - anon_sym_EQ_GT, - STATE(1213), 1, - aux_sym_handler_params_repeat1, - [56939] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2457), 1, - anon_sym_COMMA, - ACTIONS(2459), 1, - anon_sym_RPAREN, - STATE(1239), 1, - aux_sym_named_argument_list_repeat1, - [56952] = 3, + anon_sym_if, + STATE(509), 1, + sym_if_expression, + [56841] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2365), 1, + ACTIONS(2334), 1, sym_identifier, - STATE(1100), 2, + STATE(1102), 2, sym_kernel_arm, aux_sym_kernel_expression_repeat1, - [56963] = 4, + [56852] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(2461), 1, - anon_sym_EQ, - STATE(720), 1, - sym_block, - [56976] = 4, + ACTIONS(2450), 1, + anon_sym_COMMA, + ACTIONS(2453), 1, + anon_sym_RPAREN, + STATE(1210), 1, + aux_sym_tuple_pattern_repeat1, + [56865] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(988), 1, + ACTIONS(2236), 3, anon_sym_COMMA, - ACTIONS(2463), 1, - anon_sym_RBRACK, - STATE(1088), 1, - aux_sym_argument_list_repeat1, - [56989] = 4, + anon_sym_RPAREN, + anon_sym_PIPE, + [56874] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(886), 1, + ACTIONS(2307), 1, anon_sym_COMMA, - ACTIONS(2407), 1, - anon_sym_RBRACE, - STATE(1124), 1, - aux_sym_field_pattern_repeat1, - [57002] = 4, + ACTIONS(2455), 1, + anon_sym_RBRACK, + STATE(1143), 1, + aux_sym_effect_list_repeat1, + [56887] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2465), 1, + ACTIONS(2457), 1, anon_sym_EQ, - STATE(1497), 1, + STATE(724), 1, sym_block, - [57015] = 3, + [56900] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, - sym_identifier, - STATE(1041), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [57026] = 4, + ACTIONS(2459), 1, + anon_sym_COMMA, + ACTIONS(2461), 1, + anon_sym_RPAREN, + STATE(1210), 1, + aux_sym_tuple_pattern_repeat1, + [56913] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2328), 1, - anon_sym_COMMA, - ACTIONS(2467), 1, - anon_sym_GT, - STATE(1150), 1, - aux_sym__call_type_list_repeat1, - [57039] = 4, + ACTIONS(2463), 1, + anon_sym_DOT, + ACTIONS(2466), 1, + sym__statement_break, + STATE(1215), 1, + aux_sym_legacy_import_path_repeat1, + [56926] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(2469), 1, - anon_sym_EQ, - STATE(724), 1, - sym_block, - [57052] = 4, + ACTIONS(2268), 1, + anon_sym_COMMA, + ACTIONS(2468), 1, + anon_sym_RBRACE, + STATE(1261), 1, + aux_sym_map_literal_repeat1, + [56939] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1132), 1, + STATE(1121), 1, sym_field_assignment, - STATE(1514), 1, + STATE(1509), 1, sym_field_assignments, - [57065] = 4, + [56952] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2471), 1, - anon_sym_LBRACE, - ACTIONS(2473), 1, - anon_sym_SEMI, - STATE(1457), 1, - sym_namespace_body, - [57078] = 4, + ACTIONS(2470), 1, + anon_sym_COMMA, + ACTIONS(2472), 1, + anon_sym_RBRACK, + STATE(1128), 1, + aux_sym_list_pattern_repeat1, + [56965] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1132), 1, + STATE(1121), 1, sym_field_assignment, - STATE(1519), 1, + STATE(1514), 1, sym_field_assignments, - [57091] = 4, + [56978] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2475), 1, + ACTIONS(2474), 1, anon_sym_EQ, STATE(726), 1, sym_block, - [57104] = 4, + [56991] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2477), 1, - sym_identifier, - ACTIONS(2479), 1, - sym_static_stage, - STATE(1021), 1, - sym_qualified_path, - [57117] = 3, + ACTIONS(2476), 1, + anon_sym_RBRACE, + ACTIONS(2478), 1, + anon_sym_COMMA, + STATE(1221), 1, + aux_sym_field_declarations_repeat1, + [57004] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, + ACTIONS(1825), 1, sym_identifier, - STATE(1030), 2, + STATE(1026), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [57128] = 4, + [57015] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2481), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2483), 1, - anon_sym_if, - STATE(509), 1, - sym_if_expression, - [57141] = 4, + ACTIONS(2481), 1, + anon_sym_EQ, + STATE(1722), 1, + sym_block, + [57028] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1132), 1, + STATE(1121), 1, sym_field_assignment, - STATE(1525), 1, + STATE(1520), 1, sym_field_assignments, - [57154] = 2, + [57041] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2238), 3, - anon_sym_COMMA, - anon_sym_GT, - anon_sym_RPAREN, - [57163] = 3, + ACTIONS(1931), 1, + anon_sym_LBRACE, + ACTIONS(2483), 1, + anon_sym_EQ, + STATE(1550), 1, + sym_block, + [57054] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1875), 1, + ACTIONS(1825), 1, sym_identifier, - STATE(1031), 2, + STATE(1064), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [57174] = 4, + [57065] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2485), 1, + ACTIONS(2485), 3, anon_sym_COMMA, - ACTIONS(2487), 1, anon_sym_RPAREN, - STATE(1203), 1, - aux_sym_tuple_pattern_repeat1, - [57187] = 4, + anon_sym_PIPE, + [57074] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(2489), 1, - anon_sym_EQ, - STATE(729), 1, - sym_block, - [57200] = 4, + ACTIONS(2344), 1, + anon_sym_RBRACE, + ACTIONS(2487), 1, + anon_sym_COMMA, + STATE(1172), 1, + aux_sym_field_pattern_repeat1, + [57087] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1358), 1, + sym__statement_break, + ACTIONS(2346), 1, + anon_sym_where, + STATE(1590), 1, + sym_type_validation, + [57100] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2491), 1, + ACTIONS(2490), 1, anon_sym_EQ, - STATE(1624), 1, + STATE(729), 1, sym_block, - [57213] = 4, + [57113] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2493), 1, + ACTIONS(2285), 1, anon_sym_COMMA, - ACTIONS(2496), 1, + ACTIONS(2492), 1, anon_sym_RPAREN, - STATE(1236), 1, + STATE(1263), 1, aux_sym_extern_parameter_list_repeat1, - [57226] = 4, + [57126] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(2348), 1, + anon_sym_COMMA, + ACTIONS(2494), 1, + anon_sym_RPAREN, + STATE(1164), 1, + aux_sym_pattern_repeat1, + [57139] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2496), 1, + anon_sym_COMMA, + ACTIONS(2499), 1, + anon_sym_GT, + STATE(1233), 1, + aux_sym__call_type_list_repeat1, + [57152] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2501), 3, + sym__statement_break, + anon_sym_COLON_COLON, + anon_sym_as, + [57161] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2503), 1, + sym_identifier, + ACTIONS(2505), 1, + sym_static_stage, + STATE(1032), 1, + sym_qualified_path, + [57174] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1931), 1, anon_sym_LBRACE, - ACTIONS(2498), 1, + ACTIONS(2507), 1, anon_sym_EQ, - STATE(1603), 1, + STATE(1504), 1, sym_block, - [57239] = 4, + [57187] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2471), 1, + ACTIONS(2246), 1, + anon_sym_COLON, + ACTIONS(2509), 1, anon_sym_LBRACE, - ACTIONS(2500), 1, - anon_sym_SEMI, - STATE(1639), 1, - sym_namespace_body, - [57252] = 4, + STATE(1494), 1, + sym_signature_ascription, + [57200] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2457), 1, - anon_sym_COMMA, - ACTIONS(2502), 1, - anon_sym_RPAREN, - STATE(1195), 1, - aux_sym_named_argument_list_repeat1, - [57265] = 4, + STATE(1244), 1, + sym_namespace_name, + ACTIONS(2305), 2, + sym_string, + sym_identifier, + [57211] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2504), 1, + ACTIONS(988), 1, anon_sym_COMMA, - ACTIONS(2506), 1, + ACTIONS(2511), 1, anon_sym_RBRACK, - STATE(1134), 1, - aux_sym_list_pattern_repeat1, - [57278] = 4, + STATE(1071), 1, + aux_sym_argument_list_repeat1, + [57224] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2508), 1, - sym_identifier, - ACTIONS(2510), 1, - sym_static_stage, - STATE(1038), 1, - sym_qualified_path, - [57291] = 4, + ACTIONS(1356), 1, + sym__statement_break, + ACTIONS(2346), 1, + anon_sym_where, + STATE(1709), 1, + sym_type_validation, + [57237] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2512), 1, - anon_sym_COMMA, + ACTIONS(2513), 1, + sym_identifier, ACTIONS(2515), 1, - anon_sym_RPAREN, - STATE(1242), 1, - aux_sym_pattern_repeat1, - [57304] = 4, + sym_static_stage, + STATE(1047), 1, + sym_qualified_path, + [57250] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2369), 1, - anon_sym_COMMA, + ACTIONS(1923), 1, + anon_sym_LBRACE, ACTIONS(2517), 1, - anon_sym_RBRACE, - STATE(1168), 1, - aux_sym_import_member_list_repeat1, - [57317] = 4, + anon_sym_EQ, + STATE(736), 1, + sym_block, + [57263] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2338), 1, - anon_sym_COMMA, + ACTIONS(1923), 1, + anon_sym_LBRACE, ACTIONS(2519), 1, - anon_sym_RPAREN, - STATE(1154), 1, - aux_sym_pattern_repeat1, - [57330] = 4, + anon_sym_EQ, + STATE(737), 1, + sym_block, + [57276] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2277), 1, - anon_sym_COMMA, + ACTIONS(2430), 1, + anon_sym_LBRACE, ACTIONS(2521), 1, - anon_sym_RBRACE, - STATE(1156), 1, - aux_sym_map_literal_repeat1, - [57343] = 4, + anon_sym_SEMI, + STATE(1474), 1, + sym_namespace_body, + [57289] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2258), 1, + anon_sym_COMMA, + ACTIONS(2523), 1, + anon_sym_GT, + STATE(1233), 1, + aux_sym__call_type_list_repeat1, + [57302] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2106), 1, + anon_sym_DOT, + STATE(1728), 1, + sym_type_arguments, + [57315] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2355), 1, - anon_sym_COLON, - ACTIONS(2523), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - STATE(1678), 1, - sym_signature_ascription, - [57356] = 4, - ACTIONS(298), 1, - sym_line_comment, ACTIONS(2525), 1, - sym_identifier, - ACTIONS(2527), 1, - sym_static_stage, - STATE(1054), 1, - sym_qualified_path, - [57369] = 4, + anon_sym_EQ, + STATE(739), 1, + sym_block, + [57328] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2529), 1, + ACTIONS(2053), 1, anon_sym_DOT, - ACTIONS(2532), 1, + ACTIONS(2527), 1, sym__statement_break, - STATE(1248), 1, + STATE(1215), 1, aux_sym_legacy_import_path_repeat1, - [57382] = 4, + [57341] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2534), 1, + ACTIONS(2529), 1, anon_sym_EQ, - STATE(736), 1, + STATE(717), 1, sym_block, - [57395] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2536), 3, - sym__statement_break, - anon_sym_COLON_COLON, - anon_sym_as, - [57404] = 4, + [57354] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2538), 1, + ACTIONS(2531), 1, anon_sym_EQ, - STATE(737), 1, + STATE(741), 1, sym_block, - [57417] = 4, + [57367] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2118), 1, + ACTIONS(2170), 1, + anon_sym_COMMA, + ACTIONS(2533), 1, + anon_sym_RPAREN, + STATE(1145), 1, + aux_sym_positional_payload_repeat1, + [57380] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2535), 1, + anon_sym_RBRACE, + ACTIONS(2537), 1, + anon_sym_COMMA, + STATE(1252), 1, + aux_sym_field_assignments_repeat1, + [57393] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2540), 1, + sym_identifier, + STATE(647), 1, + sym_qualified_path, + STATE(655), 1, + sym_variant, + [57406] = 4, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1823), 1, + anon_sym_LT, + ACTIONS(2112), 1, anon_sym_DOT, - STATE(1735), 1, + STATE(1739), 1, sym_type_arguments, - [57430] = 4, + [57419] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, - ACTIONS(2540), 1, + ACTIONS(2542), 1, anon_sym_EQ, - STATE(1410), 1, + STATE(744), 1, sym_block, - [57443] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2277), 1, - anon_sym_COMMA, - ACTIONS(2542), 1, - anon_sym_RBRACE, - STATE(1171), 1, - aux_sym_map_literal_repeat1, - [57456] = 4, + [57432] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, ACTIONS(2544), 1, anon_sym_EQ, - STATE(739), 1, + STATE(745), 1, sym_block, - [57469] = 4, + [57445] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1949), 1, + ACTIONS(1931), 1, anon_sym_LBRACE, ACTIONS(2546), 1, anon_sym_EQ, - STATE(1513), 1, + STATE(1607), 1, sym_block, - [57482] = 4, + [57458] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, + ACTIONS(1923), 1, anon_sym_LBRACE, ACTIONS(2548), 1, anon_sym_EQ, - STATE(741), 1, + STATE(746), 1, sym_block, - [57495] = 4, + [57471] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2328), 1, + ACTIONS(2258), 1, anon_sym_COMMA, ACTIONS(2550), 1, anon_sym_GT, - STATE(1163), 1, + STATE(1197), 1, aux_sym__call_type_list_repeat1, - [57508] = 4, + [57484] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, + ACTIONS(1762), 1, + anon_sym_RBRACE, ACTIONS(2552), 1, - anon_sym_EQ, - STATE(717), 1, - sym_block, - [57521] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1833), 1, - anon_sym_LT2, - ACTIONS(2124), 1, - anon_sym_DOT, - STATE(1746), 1, - sym_type_arguments, - [57534] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, - ACTIONS(2554), 1, - anon_sym_EQ, - STATE(744), 1, - sym_block, - [57547] = 3, + anon_sym_COMMA, + STATE(1228), 1, + aux_sym_field_pattern_repeat1, + [57497] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2558), 1, - anon_sym_where, - ACTIONS(2556), 2, + ACTIONS(2555), 1, anon_sym_RBRACE, + ACTIONS(2557), 1, anon_sym_COMMA, - [57558] = 4, + STATE(1261), 1, + aux_sym_map_literal_repeat1, + [57510] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2560), 1, + ACTIONS(2370), 1, anon_sym_COMMA, - ACTIONS(2563), 1, - anon_sym_RBRACK, - STATE(1263), 1, - aux_sym_effect_list_repeat1, - [57571] = 4, + ACTIONS(2560), 1, + anon_sym_RPAREN, + STATE(1174), 1, + aux_sym_named_argument_list_repeat1, + [57523] = 4, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, + ACTIONS(2562), 1, + anon_sym_COMMA, ACTIONS(2565), 1, - anon_sym_EQ, - STATE(745), 1, - sym_block, - [57584] = 4, + anon_sym_RPAREN, + STATE(1263), 1, + aux_sym_extern_parameter_list_repeat1, + [57536] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1933), 1, - anon_sym_LBRACE, ACTIONS(2567), 1, - anon_sym_EQ, - STATE(689), 1, - sym_block, - [57597] = 4, + sym_identifier, + STATE(1246), 1, + sym_qualified_path, + [57546] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2569), 1, - anon_sym_COMMA, - ACTIONS(2572), 1, - anon_sym_GT, - STATE(1266), 1, - aux_sym_type_parameter_list_repeat1, - [57610] = 4, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1764), 1, - anon_sym_RBRACE, - ACTIONS(2574), 1, - anon_sym_COMMA, - STATE(1187), 1, - aux_sym_field_pattern_repeat1, - [57623] = 3, - ACTIONS(298), 1, - sym_line_comment, - STATE(1224), 1, - sym_namespace_name, - ACTIONS(2403), 2, - sym_string, sym_identifier, - [57634] = 4, + STATE(1156), 1, + sym_symbol_path, + [57556] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, - sym_identifier, - STATE(1132), 1, - sym_field_assignment, - STATE(1372), 1, - sym_field_assignments, - [57647] = 3, + ACTIONS(2055), 2, + anon_sym_LBRACE, + anon_sym_SEMI, + [57564] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2577), 1, + ACTIONS(2571), 1, sym_identifier, - STATE(1252), 1, + STATE(1038), 1, sym_qualified_path, - [57657] = 3, + [57574] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2579), 1, + ACTIONS(2573), 1, sym_identifier, - STATE(1298), 1, - sym_field_pattern, - [57667] = 3, + ACTIONS(2575), 1, + anon_sym_LPAREN, + [57584] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1380), 1, + ACTIONS(1378), 1, sym__statement_break, - ACTIONS(2581), 1, + ACTIONS(2577), 1, anon_sym_DASH_GT, - [57677] = 2, + [57594] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2423), 2, + ACTIONS(2395), 2, anon_sym_COMMA, anon_sym_RPAREN, - [57685] = 2, + [57602] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1368), 2, - sym__statement_break, - anon_sym_where, - [57693] = 2, + ACTIONS(2575), 1, + anon_sym_LPAREN, + ACTIONS(2579), 1, + sym_identifier, + [57612] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2583), 2, + ACTIONS(2581), 2, anon_sym_COMMA, anon_sym_GT, - [57701] = 2, + [57620] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2585), 2, - anon_sym__, + ACTIONS(1432), 2, + sym__statement_break, + anon_sym_where, + [57628] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2583), 1, sym_identifier, - [57709] = 3, + STATE(1296), 1, + sym_field_pattern, + [57638] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1404), 1, + ACTIONS(1402), 1, sym__statement_break, - ACTIONS(2587), 1, + ACTIONS(2585), 1, anon_sym_DASH_GT, - [57719] = 3, + [57648] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2589), 1, + ACTIONS(2587), 1, sym_identifier, - STATE(838), 1, + STATE(825), 1, sym_symbol_path, - [57729] = 3, + [57658] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2591), 1, - sym_float, - ACTIONS(2593), 1, - sym_integer, - [57739] = 2, + ACTIONS(2589), 2, + anon_sym__, + sym_identifier, + [57666] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2595), 2, + ACTIONS(2591), 2, anon_sym_RBRACE, anon_sym_COMMA, - [57747] = 2, + [57674] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2373), 2, + ACTIONS(2410), 2, anon_sym_RBRACE, anon_sym_COMMA, - [57755] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1756), 1, - anon_sym_LBRACE, - ACTIONS(1762), 1, - anon_sym_LPAREN, - [57765] = 3, + [57682] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, - sym_identifier, - STATE(1246), 1, - sym_symbol_path, - [57775] = 2, + ACTIONS(2593), 1, + sym_float, + ACTIONS(2595), 1, + sym_integer, + [57692] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2599), 2, + ACTIONS(2597), 2, anon_sym_COMMA, anon_sym_RPAREN, - [57783] = 2, + [57700] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1754), 1, + anon_sym_LBRACE, + ACTIONS(1760), 1, + anon_sym_LPAREN, + [57710] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2496), 2, + ACTIONS(2565), 2, anon_sym_COMMA, anon_sym_RPAREN, - [57791] = 2, + [57718] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2302), 2, + ACTIONS(2476), 2, anon_sym_RBRACE, anon_sym_COMMA, - [57799] = 3, + [57726] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2601), 1, + ACTIONS(2599), 1, anon_sym_COLON, - ACTIONS(2603), 1, + ACTIONS(2601), 1, anon_sym_EQ, - [57809] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2605), 1, - anon_sym_LBRACE, - ACTIONS(2607), 1, - anon_sym_STAR, - [57819] = 3, + [57736] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1317), 1, + STATE(1207), 1, sym_symbol_path, - [57829] = 3, + [57746] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2609), 1, + ACTIONS(2603), 1, anon_sym_DASH_GT, - ACTIONS(2611), 1, + ACTIONS(2605), 1, anon_sym_EQ_GT, - [57839] = 2, + [57756] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2613), 2, + ACTIONS(2607), 2, anon_sym__, sym_identifier, - [57847] = 3, + [57764] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2615), 1, + ACTIONS(2609), 1, + anon_sym_LBRACE, + ACTIONS(2611), 1, + anon_sym_STAR, + [57774] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2569), 1, sym_identifier, - STATE(1706), 1, - sym_field_pattern, - [57857] = 3, + STATE(1315), 1, + sym_symbol_path, + [57784] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2617), 1, + ACTIONS(2613), 1, anon_sym_COLON, - ACTIONS(2619), 1, + ACTIONS(2615), 1, anon_sym_EQ, - [57867] = 3, + [57794] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2621), 1, + ACTIONS(2617), 1, anon_sym_EQ, - ACTIONS(2623), 1, + ACTIONS(2619), 1, anon_sym_LT, - [57877] = 3, + [57804] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2625), 1, + ACTIONS(2621), 1, anon_sym_DASH_GT, - ACTIONS(2627), 1, + ACTIONS(2623), 1, anon_sym_EQ_GT, - [57887] = 2, + [57814] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2625), 1, + sym_identifier, + STATE(1714), 1, + sym_field_pattern, + [57824] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2515), 2, + ACTIONS(2330), 2, anon_sym_COMMA, anon_sym_RPAREN, - [57895] = 3, + [57832] = 3, ACTIONS(298), 1, sym_line_comment, + ACTIONS(2627), 1, + anon_sym_RBRACE, ACTIONS(2629), 1, - anon_sym_COLON, - ACTIONS(2631), 1, - anon_sym_EQ, - [57905] = 3, + anon_sym_COMMA, + [57842] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2633), 1, - anon_sym_RBRACE, - ACTIONS(2635), 1, + ACTIONS(2459), 1, anon_sym_COMMA, - [57915] = 3, + STATE(1214), 1, + aux_sym_tuple_pattern_repeat1, + [57852] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2485), 1, + ACTIONS(2631), 2, anon_sym_COMMA, - STATE(1233), 1, - aux_sym_tuple_pattern_repeat1, - [57925] = 3, + anon_sym_GT, + [57860] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2326), 1, - sym_identifier, - STATE(1345), 1, - sym_field_assignment, - [57935] = 3, + ACTIONS(2633), 1, + anon_sym_LT, + ACTIONS(2635), 1, + anon_sym_LPAREN, + [57870] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2615), 1, + ACTIONS(2625), 1, sym_identifier, - STATE(1753), 1, + STATE(1367), 1, sym_field_pattern, - [57945] = 3, + [57880] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2637), 1, - anon_sym_LT, - ACTIONS(2639), 1, - anon_sym_LPAREN, - [57955] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2641), 1, - anon_sym_LT, - ACTIONS(2643), 1, - anon_sym_LPAREN, - [57965] = 3, + anon_sym_COLON, + STATE(896), 1, + sym_signature_ascription, + [57890] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1414), 1, + ACTIONS(1412), 1, sym__statement_break, - ACTIONS(2645), 1, + ACTIONS(2639), 1, anon_sym_DASH_GT, - [57975] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2647), 1, - anon_sym_COLON, - STATE(908), 1, - sym_signature_ascription, - [57985] = 2, + [57900] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1250), 2, + ACTIONS(1262), 2, sym__statement_break, anon_sym_where, - [57993] = 2, + [57908] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1254), 2, + ACTIONS(1266), 2, sym__statement_break, anon_sym_where, - [58001] = 2, + [57916] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1260), 2, + ACTIONS(1270), 2, sym__statement_break, anon_sym_where, - [58009] = 3, + [57924] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2641), 1, + anon_sym_COLON, + ACTIONS(2643), 1, + anon_sym_EQ, + [57934] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2272), 1, sym_identifier, - STATE(1198), 1, - sym_symbol_path, - [58019] = 2, + STATE(1341), 1, + sym_field_assignment, + [57944] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2645), 1, + anon_sym_LT, + ACTIONS(2647), 1, + anon_sym_LPAREN, + [57954] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1797), 2, + ACTIONS(1801), 2, anon_sym_LBRACE, anon_sym_EQ, - [58027] = 3, + [57962] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2569), 1, + sym_identifier, + STATE(1115), 1, + sym_symbol_path, + [57972] = 3, ACTIONS(298), 1, sym_line_comment, ACTIONS(2649), 1, sym_identifier, - STATE(1273), 1, + STATE(1270), 1, sym_named_argument, - [58037] = 2, + [57982] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2262), 2, + ACTIONS(2365), 2, anon_sym_RBRACE, anon_sym_COMMA, - [58045] = 2, + [57990] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2651), 2, - anon_sym_COMMA, - anon_sym_GT, - [58053] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1238), 2, + ACTIONS(1250), 2, sym__statement_break, anon_sym_where, - [58061] = 3, + [57998] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2653), 1, + ACTIONS(2651), 1, anon_sym_DASH_GT, - ACTIONS(2655), 1, + ACTIONS(2653), 1, anon_sym_EQ_GT, - [58071] = 3, + [58008] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2657), 1, - anon_sym_EQ, - ACTIONS(2659), 1, - anon_sym_LT, - [58081] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1772), 1, + ACTIONS(1748), 1, anon_sym_LBRACE, - ACTIONS(2661), 1, + ACTIONS(2655), 1, anon_sym_PLUS, - [58091] = 3, + [58018] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2625), 1, + sym_identifier, + STATE(1364), 1, + sym_field_pattern, + [58028] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2569), 1, sym_identifier, - STATE(1305), 1, + STATE(1301), 1, sym_symbol_path, - [58101] = 2, + [58038] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1242), 2, + ACTIONS(1258), 2, sym__statement_break, anon_sym_where, - [58109] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2663), 1, - anon_sym_DASH_GT, - ACTIONS(2665), 1, - anon_sym_EQ_GT, - [58119] = 3, + [58046] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2225), 1, + ACTIONS(2200), 1, sym_identifier, - STATE(1281), 1, + STATE(1279), 1, sym_import_member, - [58129] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2667), 1, - sym_identifier, - ACTIONS(2669), 1, - anon_sym_LPAREN, - [58139] = 3, + [58056] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2671), 1, + ACTIONS(2657), 1, anon_sym_DASH_GT, - ACTIONS(2673), 1, + ACTIONS(2659), 1, anon_sym_EQ_GT, - [58149] = 2, + [58066] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2563), 2, - anon_sym_COMMA, - anon_sym_RBRACK, - [58157] = 2, + ACTIONS(1698), 1, + sym_static_stage, + ACTIONS(1700), 1, + anon_sym_effect, + [58076] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2661), 1, + anon_sym_EQ, + ACTIONS(2663), 1, + anon_sym_LT, + [58086] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2572), 2, + ACTIONS(2404), 2, anon_sym_COMMA, anon_sym_GT, - [58165] = 3, + [58094] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2675), 1, + ACTIONS(2420), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + [58102] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2665), 1, anon_sym_COLON, - ACTIONS(2677), 1, + ACTIONS(2667), 1, anon_sym_EQ, - [58175] = 3, + [58112] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2679), 1, + ACTIONS(2669), 1, anon_sym_LT, - ACTIONS(2681), 1, + ACTIONS(2671), 1, anon_sym_LPAREN, - [58185] = 3, + [58122] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2683), 1, + ACTIONS(2673), 1, anon_sym_EQ, - ACTIONS(2685), 1, + ACTIONS(2675), 1, anon_sym_LT, - [58195] = 2, + [58132] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1805), 2, + ACTIONS(2677), 1, anon_sym_LBRACE, - anon_sym_EQ, - [58203] = 3, + ACTIONS(2679), 1, + anon_sym_LT, + [58142] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2687), 1, + ACTIONS(1799), 2, + anon_sym_LBRACE, anon_sym_EQ, - ACTIONS(2689), 1, - anon_sym_LT, - [58213] = 3, + [58150] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2691), 1, - anon_sym_LBRACE, - ACTIONS(2693), 1, + ACTIONS(2681), 1, + anon_sym_EQ, + ACTIONS(2683), 1, anon_sym_LT, - [58223] = 3, + [58160] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2695), 1, + ACTIONS(2685), 1, anon_sym_LBRACE, - ACTIONS(2697), 1, + ACTIONS(2687), 1, anon_sym_LT, - [58233] = 3, + [58170] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1158), 1, + STATE(1237), 1, sym_symbol_path, - [58243] = 3, + [58180] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1388), 1, + ACTIONS(1394), 1, sym__statement_break, - ACTIONS(2699), 1, + ACTIONS(2689), 1, anon_sym_DASH_GT, - [58253] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2196), 1, - sym_identifier, - STATE(1285), 1, - sym_extern_parameter, - [58263] = 3, + [58190] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2701), 1, + ACTIONS(2691), 1, anon_sym_LBRACE, - ACTIONS(2703), 1, + ACTIONS(2693), 1, anon_sym_LT, - [58273] = 2, + [58200] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2123), 1, + sym_identifier, + STATE(1283), 1, + sym_extern_parameter, + [58210] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1392), 2, + ACTIONS(1398), 2, sym__statement_break, anon_sym_where, - [58281] = 3, + [58218] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2324), 1, + ACTIONS(2295), 1, sym_identifier, - STATE(1286), 1, + STATE(1284), 1, sym_field_declaration, - [58291] = 3, + [58228] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2705), 1, + ACTIONS(2695), 1, anon_sym_LBRACE, - ACTIONS(2707), 1, + ACTIONS(2697), 1, anon_sym_LT, - [58301] = 2, + [58238] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2532), 2, + ACTIONS(2466), 2, sym__statement_break, anon_sym_DOT, - [58309] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2709), 1, - anon_sym_LBRACE, - ACTIONS(2711), 1, - anon_sym_LT, - [58319] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2615), 1, - sym_identifier, - STATE(1451), 1, - sym_field_pattern, - [58329] = 3, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2713), 1, - sym_identifier, - STATE(1130), 1, - sym_qualified_path, - [58339] = 3, + [58246] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2715), 1, + ACTIONS(2699), 1, anon_sym_LBRACE, - ACTIONS(2717), 1, + ACTIONS(2701), 1, anon_sym_LT, - [58349] = 2, + [58256] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2315), 2, + ACTIONS(2535), 2, anon_sym_RBRACE, anon_sym_COMMA, - [58357] = 3, + [58264] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2719), 1, + ACTIONS(2703), 1, anon_sym_LBRACE, - ACTIONS(2721), 1, + ACTIONS(2705), 1, anon_sym_LT, - [58367] = 2, + [58274] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2346), 2, + ACTIONS(2555), 2, anon_sym_RBRACE, anon_sym_COMMA, - [58375] = 3, + [58282] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2723), 1, - anon_sym_LBRACE, - ACTIONS(2725), 1, - anon_sym_LT, - [58385] = 2, + ACTIONS(2625), 1, + sym_identifier, + STATE(1456), 1, + sym_field_pattern, + [58292] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2727), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [58393] = 3, + ACTIONS(2707), 1, + anon_sym_LBRACE, + ACTIONS(2709), 1, + anon_sym_LT, + [58302] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2711), 1, sym_identifier, - STATE(1176), 1, - sym_symbol_path, - [58403] = 2, + STATE(1153), 1, + sym_qualified_path, + [58312] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2729), 2, + ACTIONS(2713), 2, anon_sym_COMMA, - anon_sym_RBRACK, - [58411] = 3, + anon_sym_RPAREN, + [58320] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2715), 1, + anon_sym_LBRACE, + ACTIONS(2717), 1, + anon_sym_LT, + [58330] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1173), 1, + STATE(1167), 1, sym_symbol_path, - [58421] = 3, + [58340] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2731), 1, + ACTIONS(2719), 1, anon_sym_LT, - ACTIONS(2733), 1, + ACTIONS(2721), 1, anon_sym_LPAREN, - [58431] = 3, + [58350] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2735), 1, + ACTIONS(2723), 1, sym_identifier, - STATE(1043), 1, + STATE(1034), 1, sym_qualified_path, - [58441] = 3, + [58360] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1183), 1, + STATE(1177), 1, sym_symbol_path, - [58451] = 3, + [58370] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1186), 1, + STATE(1180), 1, sym_symbol_path, - [58461] = 3, + [58380] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2737), 1, - sym_identifier, - STATE(1044), 1, - sym_qualified_path, - [58471] = 3, + ACTIONS(2725), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + [58388] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2739), 1, + ACTIONS(2727), 1, anon_sym_LT, - ACTIONS(2741), 1, + ACTIONS(2729), 1, anon_sym_LPAREN, - [58481] = 3, + [58398] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1196), 1, + STATE(1190), 1, sym_symbol_path, - [58491] = 3, + [58408] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2743), 1, + ACTIONS(2731), 1, sym_identifier, - STATE(1056), 1, + STATE(1048), 1, sym_qualified_path, - [58501] = 3, + [58418] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2745), 1, + ACTIONS(2733), 1, anon_sym_DASH_GT, - ACTIONS(2747), 1, + ACTIONS(2735), 1, anon_sym_EQ_GT, - [58511] = 2, + [58428] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2625), 1, + sym_identifier, + STATE(1729), 1, + sym_field_pattern, + [58438] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2749), 2, + ACTIONS(2737), 2, anon_sym_COMMA, anon_sym_GT, - [58519] = 2, + [58446] = 3, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2739), 1, + sym_identifier, + STATE(1254), 1, + sym_qualified_path, + [58456] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2751), 2, + ACTIONS(2741), 2, anon_sym_COMMA, anon_sym_GT, - [58527] = 3, + [58464] = 3, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2615), 1, - sym_identifier, - STATE(1736), 1, - sym_field_pattern, - [58537] = 2, + ACTIONS(2743), 1, + anon_sym_DASH_GT, + ACTIONS(2745), 1, + anon_sym_EQ_GT, + [58474] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2085), 2, - anon_sym_LBRACE, - anon_sym_SEMI, - [58545] = 3, + ACTIONS(2747), 1, + anon_sym_RBRACE, + [58481] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2753), 1, - sym_identifier, - STATE(1260), 1, - sym_qualified_path, - [58555] = 3, + ACTIONS(1410), 1, + sym__statement_break, + [58488] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2669), 1, - anon_sym_LPAREN, - ACTIONS(2755), 1, + ACTIONS(2749), 1, sym_identifier, - [58565] = 3, + [58495] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2615), 1, - sym_identifier, - STATE(1747), 1, - sym_field_pattern, - [58575] = 3, + ACTIONS(2494), 1, + anon_sym_RBRACE, + [58502] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1716), 1, - sym_static_stage, - ACTIONS(1718), 1, - anon_sym_effect, - [58585] = 2, + ACTIONS(2751), 1, + anon_sym_RBRACE, + [58509] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1746), 1, - anon_sym_RPAREN, - [58592] = 2, + ACTIONS(2753), 1, + sym_identifier, + [58516] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2755), 1, + anon_sym_LPAREN2, + [58523] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2757), 1, - anon_sym_COLON, - [58599] = 2, + anon_sym_EQ, + [58530] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2759), 1, - anon_sym_RBRACE, - [58606] = 2, + anon_sym_RPAREN, + [58537] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2761), 1, - anon_sym_RBRACE, - [58613] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1436), 1, - sym__statement_break, - [58620] = 2, + anon_sym_COLON, + [58544] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2763), 1, - anon_sym_EQ, - [58627] = 2, + anon_sym_EQ_GT, + [58551] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2765), 1, - anon_sym_EQ, - [58634] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1408), 1, sym__statement_break, - [58641] = 2, + [58558] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2767), 1, - sym_identifier, - [58648] = 2, + anon_sym_RBRACK, + [58565] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2769), 1, - sym__statement_break, - [58655] = 2, + sym_identifier, + [58572] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2771), 1, - anon_sym_LPAREN, - [58662] = 2, + anon_sym_COLON, + [58579] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2773), 1, - anon_sym_LBRACE, - [58669] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2775), 1, - anon_sym_RPAREN, - [58676] = 2, + anon_sym_RBRACE, + [58586] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1458), 1, + ACTIONS(1436), 1, sym__statement_break, - [58683] = 2, + [58593] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2777), 1, + ACTIONS(2775), 1, sym_identifier, - [58690] = 2, + [58600] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2779), 1, + ACTIONS(2777), 1, anon_sym_LPAREN, - [58697] = 2, + [58607] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2781), 1, - anon_sym_GT, - [58704] = 2, + ACTIONS(1538), 1, + sym__statement_break, + [58614] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1540), 1, - sym__statement_break, - [58711] = 2, + ACTIONS(2779), 1, + anon_sym_DASH_GT, + [58621] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2781), 1, + anon_sym_RBRACE, + [58628] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2783), 1, anon_sym_RPAREN, - [58718] = 2, + [58635] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2785), 1, - anon_sym_DASH_GT, - [58725] = 2, + anon_sym_RPAREN, + [58642] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2787), 1, - anon_sym_RBRACE, - [58732] = 2, + anon_sym_RPAREN, + [58649] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1458), 1, + sym__statement_break, + [58656] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2789), 1, - anon_sym_RPAREN, - [58739] = 2, + anon_sym_LPAREN, + [58663] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2791), 1, - anon_sym_RPAREN, - [58746] = 2, + anon_sym_EQ_GT, + [58670] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2793), 1, anon_sym_EQ_GT, - [58753] = 2, + [58677] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2795), 1, anon_sym_GT, - [58760] = 2, + [58684] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2797), 1, - anon_sym_GT, - [58767] = 2, + ts_builtin_sym_end, + [58691] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2799), 1, - anon_sym_EQ_GT, - [58774] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1410), 1, - sym__statement_break, - [58781] = 2, + anon_sym_RPAREN, + [58698] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2801), 1, - anon_sym_LBRACE, - [58788] = 2, + anon_sym_RPAREN, + [58705] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2803), 1, - anon_sym_GT, - [58795] = 2, + anon_sym_RBRACE, + [58712] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2805), 1, sym_identifier, - [58802] = 2, + [58719] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2807), 1, - anon_sym_RPAREN, - [58809] = 2, + anon_sym_EQ, + [58726] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2809), 1, - anon_sym_RBRACE, - [58816] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2811), 1, - sym_identifier, - [58823] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2813), 1, - anon_sym_fn, - [58830] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2815), 1, anon_sym_EQ, - [58837] = 2, + [58733] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1552), 1, - sym__statement_break, - [58844] = 2, + ACTIONS(2811), 1, + anon_sym_GT, + [58740] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1442), 1, + ACTIONS(1406), 1, sym__statement_break, - [58851] = 2, + [58747] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2817), 1, - anon_sym_extra, - [58858] = 2, + ACTIONS(2813), 1, + sym_identifier, + [58754] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1510), 1, + ACTIONS(2815), 1, sym__statement_break, - [58865] = 2, + [58761] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1460), 1, + ACTIONS(1552), 1, sym__statement_break, - [58872] = 2, + [58768] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1514), 1, - sym__statement_break, - [58879] = 2, + ACTIONS(2817), 1, + anon_sym_COLON, + [58775] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2819), 1, anon_sym_extra, - [58886] = 2, + [58782] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2821), 1, - anon_sym_COLON, - [58893] = 2, + anon_sym_LBRACE, + [58789] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2823), 1, anon_sym_DASH_GT, - [58900] = 2, + [58796] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2825), 1, anon_sym_GT, - [58907] = 2, + [58803] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2827), 1, anon_sym_RBRACK, - [58914] = 2, + [58810] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2829), 1, anon_sym_EQ, - [58921] = 2, + [58817] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2831), 1, - sym_identifier, - [58928] = 2, + anon_sym_extra, + [58824] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1462), 1, + ACTIONS(1508), 1, sym__statement_break, - [58935] = 2, + [58831] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1444), 1, - sym__statement_break, - [58942] = 2, + ACTIONS(2833), 1, + anon_sym_GT, + [58838] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1446), 1, - sym__statement_break, - [58949] = 2, + ACTIONS(2835), 1, + anon_sym_COLON, + [58845] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2833), 1, - anon_sym_DASH_GT, - [58956] = 2, + ACTIONS(2837), 1, + anon_sym_GT, + [58852] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1418), 1, + ACTIONS(1460), 1, sym__statement_break, - [58963] = 2, + [58859] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2835), 1, - anon_sym_LBRACE, - [58970] = 2, + ACTIONS(1408), 1, + sym__statement_break, + [58866] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2837), 1, - sym_identifier, - [58977] = 2, + ACTIONS(2839), 1, + anon_sym_LBRACE, + [58873] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2839), 1, + ACTIONS(2841), 1, anon_sym_EQ_GT, - [58984] = 2, + [58880] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1474), 1, - sym__statement_break, - [58991] = 2, + ACTIONS(2843), 1, + sym_identifier, + [58887] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1476), 1, + ACTIONS(1462), 1, sym__statement_break, - [58998] = 2, + [58894] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1448), 1, + ACTIONS(1438), 1, sym__statement_break, - [59005] = 2, + [58901] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2841), 1, - anon_sym_RPAREN, - [59012] = 2, + ACTIONS(1442), 1, + sym__statement_break, + [58908] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2843), 1, + ACTIONS(2845), 1, anon_sym_RBRACE, - [59019] = 2, + [58915] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2845), 1, + ACTIONS(2847), 1, anon_sym_RPAREN, - [59026] = 2, + [58922] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1440), 1, - sym__statement_break, - [59033] = 2, + ACTIONS(2849), 1, + sym_identifier, + [58929] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1438), 1, + ACTIONS(1416), 1, sym__statement_break, - [59040] = 2, + [58936] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2847), 1, + ACTIONS(2851), 1, anon_sym_RPAREN, - [59047] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1478), 1, - sym__statement_break, - [59054] = 2, + [58943] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2849), 1, - anon_sym_LPAREN, - [59061] = 2, + ACTIONS(2853), 1, + anon_sym_LBRACE, + [58950] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2851), 1, + ACTIONS(2855), 1, anon_sym_DASH_GT, - [59068] = 2, + [58957] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2853), 1, + ACTIONS(2857), 1, anon_sym_DASH_GT, - [59075] = 2, + [58964] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2855), 1, - anon_sym_RPAREN, - [59082] = 2, + ACTIONS(1472), 1, + sym__statement_break, + [58971] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2857), 1, + ACTIONS(2859), 1, anon_sym_EQ, - [59089] = 2, + [58978] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2859), 1, - anon_sym_RPAREN, - [59096] = 2, + ACTIONS(1382), 1, + sym__statement_break, + [58985] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2861), 1, + anon_sym_RPAREN, + [58992] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2863), 1, anon_sym_EQ, - [59103] = 2, + [58999] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1444), 1, sym__statement_break, - [59110] = 2, + [59006] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2863), 1, - anon_sym_GT, - [59117] = 2, + ACTIONS(1474), 1, + sym__statement_break, + [59013] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2865), 1, - anon_sym_RBRACK, - [59124] = 2, + anon_sym_RPAREN, + [59020] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2867), 1, - sym_identifier, - [59131] = 2, + ACTIONS(1476), 1, + sym__statement_break, + [59027] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1484), 1, + ACTIONS(1446), 1, sym__statement_break, - [59138] = 2, + [59034] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1384), 1, - sym__statement_break, - [59145] = 2, + ACTIONS(2867), 1, + anon_sym_GT, + [59041] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2869), 1, anon_sym_RBRACK, - [59152] = 2, + [59048] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2871), 1, - anon_sym_RBRACE, - [59159] = 2, + anon_sym_RBRACK, + [59055] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2873), 1, - anon_sym_LPAREN, - [59166] = 2, + sym_identifier, + [59062] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2875), 1, - anon_sym_LBRACE, - [59173] = 2, + ACTIONS(1480), 1, + sym__statement_break, + [59069] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2877), 1, - sym__statement_break, - [59180] = 2, + ACTIONS(2875), 1, + anon_sym_fn, + [59076] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2879), 1, + ACTIONS(2877), 1, anon_sym_RPAREN, - [59187] = 2, + [59083] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1486), 1, + ACTIONS(1448), 1, sym__statement_break, - [59194] = 2, + [59090] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2881), 1, - sym__statement_break, - [59201] = 2, + ACTIONS(2879), 1, + anon_sym_LPAREN, + [59097] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1490), 1, + ACTIONS(1484), 1, sym__statement_break, - [59208] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2883), 1, - anon_sym_module, - [59215] = 2, + [59104] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1492), 1, - sym__statement_break, - [59222] = 2, + ACTIONS(2881), 1, + sym_identifier, + [59111] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1420), 1, - sym__statement_break, - [59229] = 2, + ACTIONS(2883), 1, + anon_sym_RPAREN, + [59118] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2885), 1, - anon_sym_LPAREN, - [59236] = 2, + anon_sym_RBRACE, + [59125] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2887), 1, anon_sym_GT, - [59243] = 2, + [59132] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2889), 1, sym_identifier, - [59250] = 2, + [59139] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1486), 1, + sym__statement_break, + [59146] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2891), 1, - sym_identifier, - [59257] = 2, + anon_sym_LPAREN, + [59153] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1488), 1, + sym__statement_break, + [59160] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2893), 1, sym_identifier, - [59264] = 2, + [59167] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2895), 1, - anon_sym_LBRACE, - [59271] = 2, + ACTIONS(1490), 1, + sym__statement_break, + [59174] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1528), 1, + ACTIONS(1418), 1, sym__statement_break, - [59278] = 2, + [59181] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2895), 1, + anon_sym_LPAREN, + [59188] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2897), 1, - anon_sym_RPAREN, - [59285] = 2, + anon_sym_LPAREN2, + [59195] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2899), 1, - anon_sym_EQ_GT, - [59292] = 2, + anon_sym_effect, + [59202] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2901), 1, - sym_identifier, - [59299] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1422), 1, sym__statement_break, - [59306] = 2, + [59209] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2903), 1, - anon_sym_COLON, - [59313] = 2, + anon_sym_LBRACE, + [59216] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1524), 1, + sym__statement_break, + [59223] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2905), 1, - anon_sym_EQ, - [59320] = 2, + sym_identifier, + [59230] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2907), 1, - anon_sym_RBRACK, - [59327] = 2, + anon_sym_COLON, + [59237] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2909), 1, - anon_sym_RPAREN, - [59334] = 2, + anon_sym_EQ, + [59244] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2911), 1, - anon_sym_LPAREN, - [59341] = 2, + sym__statement_break, + [59251] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2913), 1, - anon_sym_GT, - [59348] = 2, + ACTIONS(1420), 1, + sym__statement_break, + [59258] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1450), 1, - sym__statement_break, - [59355] = 2, + ACTIONS(2913), 1, + anon_sym_GT, + [59265] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2915), 1, - anon_sym_RPAREN, - [59362] = 2, + anon_sym_LBRACE, + [59272] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2917), 1, - anon_sym_LPAREN, - [59369] = 2, + anon_sym_RBRACK, + [59279] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2919), 1, - anon_sym_RBRACK, - [59376] = 2, + anon_sym_RPAREN, + [59286] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2921), 1, - anon_sym_GT, - [59383] = 2, + anon_sym_LPAREN, + [59293] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2923), 1, - anon_sym_GT, - [59390] = 2, + sym_identifier, + [59300] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2925), 1, - anon_sym_LBRACE, - [59397] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1504), 1, - sym__statement_break, - [59404] = 2, + anon_sym_COLON, + [59307] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2927), 1, - anon_sym_RPAREN, - [59411] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1386), 1, - sym__statement_break, - [59418] = 2, + anon_sym_GT, + [59314] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2929), 1, - sym_identifier, - [59425] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1498), 1, - sym__statement_break, - [59432] = 2, + anon_sym_RPAREN, + [59321] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2931), 1, - anon_sym_GT, - [59439] = 2, + anon_sym_RPAREN, + [59328] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2933), 1, - anon_sym_RBRACE, - [59446] = 2, + anon_sym_GT, + [59335] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2935), 1, - sym_identifier, - [59453] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2937), 1, - anon_sym_LBRACE, - [59460] = 2, + anon_sym_RBRACE, + [59342] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1456), 1, + ACTIONS(1384), 1, sym__statement_break, - [59467] = 2, + [59349] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2939), 1, - anon_sym_EQ_GT, - [59474] = 2, + ACTIONS(1494), 1, + sym__statement_break, + [59356] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1500), 1, - sym__statement_break, - [59481] = 2, + ACTIONS(2937), 1, + anon_sym_GT, + [59363] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1502), 1, - sym__statement_break, - [59488] = 2, + ACTIONS(2939), 1, + anon_sym_EQ_GT, + [59370] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2941), 1, - sym_identifier, - [59495] = 2, + anon_sym_RPAREN, + [59377] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2943), 1, sym_identifier, - [59502] = 2, + [59384] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2945), 1, - sym_identifier, - [59509] = 2, + anon_sym_LBRACE, + [59391] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2947), 1, - anon_sym_COLON, - [59516] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1464), 1, - sym__statement_break, - [59523] = 2, + sym_identifier, + [59398] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2949), 1, - anon_sym_fn, - [59530] = 2, + sym_identifier, + [59405] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1370), 1, + ACTIONS(1496), 1, sym__statement_break, - [59537] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2665), 1, - anon_sym_EQ_GT, - [59544] = 2, + [59412] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1424), 1, + ACTIONS(1456), 1, sym__statement_break, - [59551] = 2, + [59419] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2951), 1, - anon_sym_type, - [59558] = 2, + sym_identifier, + [59426] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1506), 1, - sym__statement_break, - [59565] = 2, + ACTIONS(2953), 1, + anon_sym_RPAREN, + [59433] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2953), 1, - sym_identifier, - [59572] = 2, + ACTIONS(2745), 1, + anon_sym_EQ_GT, + [59440] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2955), 1, + sym_identifier, + [59447] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1464), 1, sym__statement_break, - [59579] = 2, + [59454] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2957), 1, - anon_sym_COLON, - [59586] = 2, + ACTIONS(1498), 1, + sym__statement_break, + [59461] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1508), 1, + ACTIONS(1500), 1, sym__statement_break, - [59593] = 2, + [59468] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2957), 1, + sym_identifier, + [59475] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2959), 1, - anon_sym_RBRACE, - [59600] = 2, + sym_identifier, + [59482] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2961), 1, - anon_sym_GT, - [59607] = 2, + ACTIONS(1450), 1, + sym__statement_break, + [59489] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1857), 1, - anon_sym_COLON, - [59614] = 2, + ACTIONS(2961), 1, + anon_sym_RBRACE, + [59496] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2963), 1, - anon_sym_LPAREN, - [59621] = 2, + sym__statement_break, + [59503] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1572), 1, + ACTIONS(1422), 1, sym__statement_break, - [59628] = 2, + [59510] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2965), 1, - anon_sym_RBRACE, - [59635] = 2, + anon_sym_RBRACK, + [59517] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2967), 1, - anon_sym_COLON, - [59642] = 2, + ACTIONS(1504), 1, + sym__statement_break, + [59524] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2969), 1, - anon_sym_EQ_GT, - [59649] = 2, + ACTIONS(2967), 1, + anon_sym_RBRACE, + [59531] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1452), 1, - sym__statement_break, - [59656] = 2, + ACTIONS(2969), 1, + anon_sym_COLON, + [59538] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2971), 1, - anon_sym_RBRACE, - [59663] = 2, + anon_sym_type, + [59545] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2973), 1, - anon_sym_DASH_GT, - [59670] = 2, + sym_identifier, + [59552] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1847), 1, + anon_sym_COLON, + [59559] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2975), 1, - anon_sym_RBRACE, - [59677] = 2, + anon_sym_DASH_GT, + [59566] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2977), 1, - anon_sym_RPAREN, - [59684] = 2, + anon_sym_RBRACE, + [59573] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2979), 1, anon_sym_RPAREN, - [59691] = 2, + [59580] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2981), 1, - anon_sym_EQ_GT, - [59698] = 2, + anon_sym_RPAREN, + [59587] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2983), 1, anon_sym_EQ_GT, - [59705] = 2, + [59594] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1454), 1, + ACTIONS(1506), 1, sym__statement_break, - [59712] = 2, + [59601] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1512), 1, - sym__statement_break, - [59719] = 2, + ACTIONS(2985), 1, + anon_sym_EQ_GT, + [59608] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2985), 1, - anon_sym_DASH_GT, - [59726] = 2, + ACTIONS(1368), 1, + sym__statement_break, + [59615] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2987), 1, - anon_sym_GT, - [59733] = 2, + anon_sym_DASH_GT, + [59622] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2989), 1, - anon_sym_RBRACK, - [59740] = 2, + anon_sym_GT, + [59629] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2991), 1, - anon_sym_EQ_GT, - [59747] = 2, + anon_sym_RBRACK, + [59636] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2993), 1, - anon_sym_DASH_GT, - [59754] = 2, + anon_sym_EQ_GT, + [59643] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2995), 1, - anon_sym_RPAREN, - [59761] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1466), 1, - sym__statement_break, - [59768] = 2, + anon_sym_RBRACE, + [59650] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2997), 1, - anon_sym_DASH_GT, - [59775] = 2, + anon_sym_RPAREN, + [59657] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1426), 1, + ACTIONS(1570), 1, sym__statement_break, - [59782] = 2, + [59664] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(2999), 1, - anon_sym_RPAREN, - [59789] = 2, + anon_sym_DASH_GT, + [59671] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3001), 1, - sym_identifier, - [59796] = 2, + anon_sym_COLON, + [59678] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3003), 1, - anon_sym_LPAREN, - [59803] = 2, + anon_sym_RPAREN, + [59685] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3005), 1, - sym_identifier, - [59810] = 2, + anon_sym_EQ_GT, + [59692] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3007), 1, - anon_sym_COLON, - [59817] = 2, + anon_sym_LPAREN, + [59699] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3009), 1, sym_identifier, - [59824] = 2, + [59706] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1466), 1, + sym__statement_break, + [59713] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3011), 1, - sym_identifier, - [59831] = 2, + anon_sym_DASH_GT, + [59720] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3013), 1, - anon_sym_RBRACE, - [59838] = 2, + sym_identifier, + [59727] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1510), 1, + sym__statement_break, + [59734] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3015), 1, sym_identifier, - [59845] = 2, + [59741] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3017), 1, + sym_identifier, + [59748] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1718), 1, + anon_sym_RPAREN, + [59755] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1366), 1, + sym__statement_break, + [59762] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1424), 1, + sym__statement_break, + [59769] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3019), 1, + anon_sym_LPAREN, + [59776] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1452), 1, + sym__statement_break, + [59783] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3017), 1, - sym_identifier, - [59852] = 2, + ACTIONS(2575), 1, + anon_sym_LPAREN, + [59790] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3019), 1, - sym_identifier, - [59859] = 2, + ACTIONS(1454), 1, + sym__statement_break, + [59797] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3021), 1, - sym_identifier, - [59866] = 2, + anon_sym_PIPE, + [59804] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3023), 1, - sym_identifier, - [59873] = 2, + anon_sym_COLON, + [59811] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3025), 1, sym_identifier, - [59880] = 2, + [59818] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3027), 1, - anon_sym_RBRACE, - [59887] = 2, + anon_sym_DASH_GT, + [59825] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3029), 1, - anon_sym_LPAREN, - [59894] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1494), 1, - sym__statement_break, - [59901] = 2, + anon_sym_RBRACE, + [59832] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2669), 1, - anon_sym_LPAREN, - [59908] = 2, + ACTIONS(3031), 1, + sym_identifier, + [59839] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1366), 1, + ACTIONS(1492), 1, sym__statement_break, - [59915] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3031), 1, - anon_sym_PIPE, - [59922] = 2, + [59846] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3033), 1, - sym_identifier, - [59929] = 2, + anon_sym_RBRACE, + [59853] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3035), 1, - anon_sym_COLON, - [59936] = 2, + anon_sym_LBRACE, + [59860] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3037), 1, anon_sym_LBRACE, - [59943] = 2, + [59867] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3039), 1, - anon_sym_PIPE, - [59950] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1496), 1, sym__statement_break, - [59957] = 2, + [59874] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1516), 1, + ACTIONS(1502), 1, sym__statement_break, - [59964] = 2, + [59881] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3041), 1, - anon_sym_RPAREN, - [59971] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(990), 1, - anon_sym_RPAREN, - [59978] = 2, + anon_sym_LPAREN, + [59888] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3043), 1, - anon_sym_LBRACE, - [59985] = 2, + anon_sym_LPAREN, + [59895] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3045), 1, - sym_identifier, - [59992] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1518), 1, - sym__statement_break, - [59999] = 2, + anon_sym_LPAREN2, + [59902] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3047), 1, - anon_sym_LPAREN, - [60006] = 2, + anon_sym_RPAREN, + [59909] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3049), 1, sym_identifier, - [60013] = 2, + [59916] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3051), 1, - anon_sym_LPAREN2, - [60020] = 2, + sym_identifier, + [59923] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3053), 1, - anon_sym_LBRACE, - [60027] = 2, + anon_sym_COLON, + [59930] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3055), 1, - sym_identifier, - [60034] = 2, + anon_sym_RPAREN, + [59937] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3057), 1, - sym_identifier, - [60041] = 2, + ACTIONS(1514), 1, + sym__statement_break, + [59944] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1520), 1, - sym__statement_break, - [60048] = 2, + ACTIONS(3057), 1, + anon_sym_LPAREN, + [59951] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3059), 1, - anon_sym_RPAREN, - [60055] = 2, + anon_sym_RBRACE, + [59958] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3061), 1, - sym_identifier, - [60062] = 2, + ACTIONS(1440), 1, + sym__statement_break, + [59965] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3063), 1, - anon_sym_LPAREN, - [60069] = 2, + ACTIONS(990), 1, + anon_sym_RPAREN, + [59972] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3065), 1, - sym_identifier, - [60076] = 2, + ACTIONS(3061), 1, + anon_sym_LBRACE, + [59979] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1522), 1, + ACTIONS(1516), 1, sym__statement_break, - [60083] = 2, + [59986] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1524), 1, - sym__statement_break, - [60090] = 2, + ACTIONS(3063), 1, + anon_sym_GT, + [59993] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1428), 1, - sym__statement_break, - [60097] = 2, + ACTIONS(3065), 1, + anon_sym_module, + [60000] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3067), 1, - sym_identifier, - [60104] = 2, + anon_sym_fn, + [60007] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3069), 1, - anon_sym_LBRACE, - [60111] = 2, + anon_sym_LPAREN, + [60014] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1430), 1, + ACTIONS(1518), 1, sym__statement_break, - [60118] = 2, + [60021] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3071), 1, - anon_sym_else, - [60125] = 2, + anon_sym_LBRACE, + [60028] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3073), 1, - anon_sym_RBRACE, - [60132] = 2, + anon_sym_EQ_GT, + [60035] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3075), 1, - anon_sym_GT, - [60139] = 2, + anon_sym_RPAREN, + [60042] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1520), 1, + sym__statement_break, + [60049] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3077), 1, - anon_sym_LBRACE, - [60146] = 2, + anon_sym_GT, + [60056] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1530), 1, + ACTIONS(1522), 1, + sym__statement_break, + [60063] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1426), 1, sym__statement_break, - [60153] = 2, + [60070] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3079), 1, - anon_sym_RPAREN, - [60160] = 2, + anon_sym_LPAREN, + [60077] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3081), 1, - anon_sym_RBRACE, - [60167] = 2, + anon_sym_LBRACE, + [60084] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3083), 1, - anon_sym_GT, - [60174] = 2, + anon_sym_RBRACE, + [60091] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3085), 1, + ACTIONS(1728), 1, anon_sym_RPAREN, - [60181] = 2, + [60098] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3087), 1, - anon_sym_QMARK, - [60188] = 2, + ACTIONS(1428), 1, + sym__statement_break, + [60105] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3089), 1, - anon_sym_LPAREN, - [60195] = 2, + ACTIONS(3085), 1, + anon_sym_RPAREN, + [60112] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3091), 1, + ACTIONS(3087), 1, anon_sym_LBRACE, - [60202] = 2, + [60119] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1526), 1, + ACTIONS(1528), 1, sym__statement_break, - [60209] = 2, + [60126] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1740), 1, - anon_sym_RPAREN, - [60216] = 2, + ACTIONS(3089), 1, + anon_sym_LPAREN, + [60133] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1532), 1, + ACTIONS(3091), 1, + anon_sym_else, + [60140] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1526), 1, sym__statement_break, - [60223] = 2, + [60147] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3093), 1, - anon_sym_LPAREN, - [60230] = 2, + anon_sym_LBRACE, + [60154] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3095), 1, - sym_identifier, - [60237] = 2, + anon_sym_GT, + [60161] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3097), 1, - anon_sym_RPAREN, - [60244] = 2, + sym_identifier, + [60168] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3099), 1, - anon_sym_LPAREN, - [60251] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3101), 1, - anon_sym_DOT, - [60258] = 2, + anon_sym_EQ_GT, + [60175] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3103), 1, + ACTIONS(1530), 1, sym__statement_break, - [60265] = 2, + [60182] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3105), 1, + ACTIONS(3101), 1, anon_sym_LBRACE, - [60272] = 2, + [60189] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3107), 1, - sym__statement_break, - [60279] = 2, + ACTIONS(3103), 1, + anon_sym_else, + [60196] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2655), 1, - anon_sym_EQ_GT, - [60286] = 2, + ACTIONS(3105), 1, + anon_sym_LPAREN, + [60203] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1402), 1, - sym__statement_break, - [60293] = 2, + ACTIONS(3107), 1, + anon_sym_RPAREN, + [60210] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3109), 1, - anon_sym_LBRACE, - [60300] = 2, + anon_sym_QMARK, + [60217] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3111), 1, - anon_sym_LBRACE, - [60307] = 2, + anon_sym_RPAREN, + [60224] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3113), 1, - anon_sym_else, - [60314] = 2, + anon_sym_GT, + [60231] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3115), 1, - anon_sym_LPAREN, - [60321] = 2, + anon_sym_LBRACE, + [60238] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3117), 1, - anon_sym_RPAREN, - [60328] = 2, + sym__statement_break, + [60245] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3119), 1, - anon_sym_GT, - [60335] = 2, + anon_sym_RPAREN, + [60252] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1400), 1, + sym__statement_break, + [60259] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3121), 1, - anon_sym_RPAREN, - [60342] = 2, + anon_sym_LBRACE, + [60266] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3123), 1, - anon_sym_GT, - [60349] = 2, + anon_sym_LBRACE, + [60273] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3125), 1, anon_sym_LBRACE, - [60356] = 2, + [60280] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3127), 1, - anon_sym_LPAREN2, - [60363] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1534), 1, - sym__statement_break, - [60370] = 2, + anon_sym_RPAREN, + [60287] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3129), 1, - anon_sym_RBRACE, - [60377] = 2, + sym__statement_break, + [60294] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3131), 1, - anon_sym_LBRACE, - [60384] = 2, + anon_sym_PIPE, + [60301] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3133), 1, - anon_sym_RPAREN, - [60391] = 2, + anon_sym_LPAREN, + [60308] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3135), 1, anon_sym_LBRACE, - [60398] = 2, + [60315] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3137), 1, anon_sym_RPAREN, - [60405] = 2, + [60322] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3139), 1, + anon_sym_RPAREN, + [60329] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2653), 1, anon_sym_EQ_GT, - [60412] = 2, + [60336] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1536), 1, + ACTIONS(1532), 1, sym__statement_break, - [60419] = 2, + [60343] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3141), 1, anon_sym_COLON, - [60426] = 2, + [60350] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3143), 1, - anon_sym_LBRACE, - [60433] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3145), 1, anon_sym_COLON, - [60440] = 2, + [60357] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3147), 1, - anon_sym_RPAREN, - [60447] = 2, + ACTIONS(3145), 1, + sym__statement_break, + [60364] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3149), 1, + ACTIONS(1534), 1, sym__statement_break, - [60454] = 2, + [60371] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1538), 1, - sym__statement_break, - [60461] = 2, + ACTIONS(3147), 1, + anon_sym_LPAREN, + [60378] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1432), 1, + ACTIONS(3149), 1, sym__statement_break, - [60468] = 2, + [60385] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3151), 1, - sym__statement_break, - [60475] = 2, + anon_sym_PIPE, + [60392] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3153), 1, anon_sym_COLON, - [60482] = 2, + [60399] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1542), 1, + ACTIONS(3155), 1, + anon_sym_COLON, + [60406] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(1536), 1, sym__statement_break, - [60489] = 2, + [60413] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3155), 1, - anon_sym_LPAREN, - [60496] = 2, + ACTIONS(1430), 1, + sym__statement_break, + [60420] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3157), 1, - anon_sym_COLON, - [60503] = 2, + anon_sym_LT2, + [60427] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3159), 1, - anon_sym_PIPE, - [60510] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3161), 1, sym_identifier, - [60517] = 2, + [60434] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1540), 1, sym__statement_break, - [60524] = 2, + [60441] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3161), 1, + anon_sym_LPAREN, + [60448] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3163), 1, - sym_identifier, - [60531] = 2, + anon_sym_COLON, + [60455] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3165), 1, - anon_sym_COLON, - [60538] = 2, + anon_sym_LPAREN2, + [60462] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(1883), 1, anon_sym_COLON, - [60545] = 2, + [60469] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3167), 1, - ts_builtin_sym_end, - [60552] = 2, + anon_sym_RPAREN, + [60476] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1568), 1, + ACTIONS(1542), 1, sym__statement_break, - [60559] = 2, + [60483] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3169), 1, - anon_sym_LPAREN, - [60566] = 2, + sym_identifier, + [60490] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3171), 1, - anon_sym_LPAREN, - [60573] = 2, + anon_sym_GT, + [60497] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3173), 1, - anon_sym_LPAREN2, - [60580] = 2, + anon_sym_LPAREN, + [60504] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3175), 1, - anon_sym_LPAREN, - [60587] = 2, + sym_identifier, + [60511] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3177), 1, - anon_sym_RPAREN, - [60594] = 2, + sym_identifier, + [60518] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3179), 1, - anon_sym_module, - [60601] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1546), 1, - sym__statement_break, - [60608] = 2, + anon_sym_effect, + [60525] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3181), 1, sym_identifier, - [60615] = 2, + [60532] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3183), 1, - sym__statement_break, - [60622] = 2, + anon_sym_LPAREN, + [60539] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3185), 1, - sym__statement_break, - [60629] = 2, + sym_identifier, + [60546] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3187), 1, - anon_sym_RBRACE, - [60636] = 2, + ACTIONS(1732), 1, + anon_sym_RPAREN, + [60553] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1548), 1, + ACTIONS(1544), 1, sym__statement_break, - [60643] = 2, + [60560] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(3187), 1, + anon_sym_RBRACE, + [60567] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3189), 1, - sym_identifier, - [60650] = 2, + anon_sym_DOT, + [60574] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3191), 1, - anon_sym_LPAREN, - [60657] = 2, + anon_sym_else, + [60581] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3193), 1, - anon_sym_EQ_GT, - [60664] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(1744), 1, - anon_sym_RPAREN, - [60671] = 2, + anon_sym_LPAREN, + [60588] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3195), 1, - anon_sym_EQ, - [60678] = 2, + anon_sym_RPAREN, + [60595] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3197), 1, - sym_identifier, - [60685] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(664), 1, sym__statement_break, - [60692] = 2, + [60602] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3199), 1, - anon_sym_else, - [60699] = 2, + anon_sym_GT, + [60609] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3201), 1, - anon_sym_LPAREN, - [60706] = 2, + sym_identifier, + [60616] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3203), 1, - anon_sym_RPAREN, - [60713] = 2, + sym_identifier, + [60623] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1550), 1, + ACTIONS(1546), 1, sym__statement_break, - [60720] = 2, + [60630] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3205), 1, sym_identifier, - [60727] = 2, + [60637] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3207), 1, - sym_identifier, - [60734] = 2, + anon_sym_LBRACE, + [60644] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3209), 1, - sym_identifier, - [60741] = 2, + anon_sym_LPAREN, + [60651] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3211), 1, - anon_sym_LBRACE, - [60748] = 2, + sym_identifier, + [60658] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3213), 1, sym_identifier, - [60755] = 2, + [60665] = 2, + ACTIONS(298), 1, + sym_line_comment, + ACTIONS(2605), 1, + anon_sym_EQ_GT, + [60672] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3215), 1, - anon_sym_LBRACE, - [60762] = 2, + anon_sym_LPAREN, + [60679] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3217), 1, - anon_sym_LPAREN, - [60769] = 2, + sym_identifier, + [60686] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3219), 1, - anon_sym_effect, - [60776] = 2, + sym_identifier, + [60693] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3221), 1, sym_identifier, - [60783] = 2, + [60700] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3223), 1, - anon_sym_COLON, - [60790] = 2, + anon_sym_EQ_GT, + [60707] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3225), 1, - anon_sym_LPAREN, - [60797] = 2, + anon_sym_LBRACE, + [60714] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3227), 1, sym_identifier, - [60804] = 2, + [60721] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3229), 1, sym_identifier, - [60811] = 2, + [60728] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3231), 1, - anon_sym_LBRACE, - [60818] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(2611), 1, - anon_sym_EQ_GT, - [60825] = 2, + sym_identifier, + [60735] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3233), 1, - anon_sym_LBRACE, - [60832] = 2, + anon_sym_RBRACE, + [60742] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3235), 1, - sym_identifier, - [60839] = 2, + anon_sym_LBRACE, + [60749] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3237), 1, - anon_sym_DOT_DOT, - [60846] = 2, + sym_identifier, + [60756] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3239), 1, - sym_identifier, - [60853] = 2, + anon_sym_LPAREN, + [60763] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3241), 1, - sym__statement_break, - [60860] = 2, + anon_sym_DOT_DOT, + [60770] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3243), 1, - anon_sym_COLON, - [60867] = 2, + sym_identifier, + [60777] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3245), 1, sym_identifier, - [60874] = 2, + [60784] = 2, ACTIONS(298), 1, sym_line_comment, ACTIONS(3247), 1, - anon_sym_LPAREN, - [60881] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3249), 1, - anon_sym_COLON, - [60888] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3251), 1, - sym_identifier, - [60895] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3253), 1, sym_identifier, - [60902] = 2, - ACTIONS(298), 1, - sym_line_comment, - ACTIONS(3255), 1, - anon_sym_RPAREN, - [60909] = 2, + [60791] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3257), 1, + ACTIONS(3249), 1, anon_sym_GT, - [60916] = 2, + [60798] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1434), 1, + ACTIONS(664), 1, sym__statement_break, - [60923] = 2, + [60805] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3259), 1, + ACTIONS(3251), 1, sym_identifier, - [60930] = 2, + [60812] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3261), 1, + ACTIONS(3253), 1, anon_sym_QMARK, - [60937] = 2, + [60819] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2340), 1, - anon_sym_RBRACE, - [60944] = 2, + ACTIONS(3255), 1, + anon_sym_EQ, + [60826] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3263), 1, + ACTIONS(3257), 1, anon_sym_LPAREN, - [60951] = 2, + [60833] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3265), 1, + ACTIONS(3259), 1, anon_sym_GT, - [60958] = 2, + [60840] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3267), 1, + ACTIONS(3261), 1, anon_sym_GT, - [60965] = 2, + [60847] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3269), 1, + ACTIONS(3263), 1, anon_sym_LPAREN, - [60972] = 2, + [60854] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3271), 1, + ACTIONS(3265), 1, anon_sym_GT, - [60979] = 2, + [60861] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3273), 1, - anon_sym_RBRACE, - [60986] = 2, + ACTIONS(1548), 1, + sym__statement_break, + [60868] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1554), 1, + ACTIONS(3267), 1, sym__statement_break, - [60993] = 2, + [60875] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3275), 1, + ACTIONS(3269), 1, anon_sym_LBRACE, - [61000] = 2, + [60882] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3277), 1, + ACTIONS(3271), 1, anon_sym_LPAREN, - [61007] = 2, + [60889] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1412), 1, + ACTIONS(1512), 1, sym__statement_break, - [61014] = 2, + [60896] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3279), 1, + ACTIONS(3273), 1, anon_sym_LBRACE, - [61021] = 2, + [60903] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3281), 1, - anon_sym_LPAREN2, - [61028] = 2, + ACTIONS(3275), 1, + anon_sym_LPAREN, + [60910] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3283), 1, + ACTIONS(3277), 1, sym_identifier, - [61035] = 2, + [60917] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3285), 1, + ACTIONS(3279), 1, anon_sym_LPAREN, - [61042] = 2, + [60924] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3287), 1, - sym__statement_break, - [61049] = 2, + ACTIONS(2350), 1, + anon_sym_RBRACE, + [60931] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3289), 1, + ACTIONS(3281), 1, sym_identifier, - [61056] = 2, + [60938] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3291), 1, + ACTIONS(3283), 1, anon_sym_QMARK, - [61063] = 2, + [60945] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3293), 1, + ACTIONS(3285), 1, anon_sym_fn, - [61070] = 2, + [60952] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3295), 1, + ACTIONS(3287), 1, anon_sym_effect, - [61077] = 2, + [60959] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3297), 1, + ACTIONS(3289), 1, anon_sym_module, - [61084] = 2, + [60966] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3299), 1, - sym__statement_break, - [61091] = 2, + ACTIONS(3291), 1, + anon_sym_RBRACE, + [60973] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3301), 1, - anon_sym_RPAREN, - [61098] = 2, + ACTIONS(3293), 1, + anon_sym_module, + [60980] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3303), 1, - anon_sym_EQ_GT, - [61105] = 2, + ACTIONS(1550), 1, + sym__statement_break, + [60987] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3305), 1, + ACTIONS(3295), 1, anon_sym_fn, - [61112] = 2, + [60994] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3307), 1, + ACTIONS(3297), 1, anon_sym_effect, - [61119] = 2, + [61001] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3309), 1, + ACTIONS(3299), 1, anon_sym_module, - [61126] = 2, + [61008] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1560), 1, + ACTIONS(3301), 1, sym__statement_break, - [61133] = 2, + [61015] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1564), 1, + ACTIONS(3303), 1, sym__statement_break, - [61140] = 2, + [61022] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3311), 1, + ACTIONS(3305), 1, anon_sym_DOT, - [61147] = 2, + [61029] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3313), 1, + ACTIONS(3307), 1, anon_sym_RBRACE, - [61154] = 2, + [61036] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3315), 1, + ACTIONS(3309), 1, anon_sym_GT, - [61161] = 2, + [61043] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1556), 1, + ACTIONS(1434), 1, sym__statement_break, - [61168] = 2, + [61050] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3317), 1, - sym_identifier, - [61175] = 2, + ACTIONS(3311), 1, + anon_sym_RPAREN, + [61057] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3319), 1, + ACTIONS(3313), 1, anon_sym_GT, - [61182] = 2, + [61064] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3321), 1, - sym_identifier, - [61189] = 2, + ACTIONS(3315), 1, + anon_sym_EQ_GT, + [61071] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(554), 1, + ACTIONS(1558), 1, sym__statement_break, - [61196] = 2, + [61078] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1714), 1, - anon_sym_type, - [61203] = 2, + ACTIONS(1562), 1, + sym__statement_break, + [61085] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3323), 1, - anon_sym_GT, - [61210] = 2, + ACTIONS(1566), 1, + sym__statement_break, + [61092] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3325), 1, - anon_sym_COLON, - [61217] = 2, + ACTIONS(3317), 1, + sym_identifier, + [61099] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3327), 1, + ACTIONS(3319), 1, anon_sym_DOT, - [61224] = 2, + [61106] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3329), 1, - anon_sym_RBRACE, - [61231] = 2, + ACTIONS(3321), 1, + anon_sym_LPAREN, + [61113] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3331), 1, + ACTIONS(3323), 1, anon_sym_LPAREN, - [61238] = 2, + [61120] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1795), 1, - anon_sym_LBRACE, - [61245] = 2, + ACTIONS(1696), 1, + anon_sym_type, + [61127] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(1566), 1, + ACTIONS(1554), 1, sym__statement_break, - [61252] = 2, + [61134] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3333), 1, - anon_sym_EQ_GT, - [61259] = 2, + ACTIONS(3325), 1, + anon_sym_COLON, + [61141] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3335), 1, - anon_sym_LPAREN, - [61266] = 2, + ACTIONS(3327), 1, + anon_sym_COLON, + [61148] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(2519), 1, - anon_sym_RBRACE, - [61273] = 2, + ACTIONS(554), 1, + sym__statement_break, + [61155] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3337), 1, + ACTIONS(3329), 1, anon_sym_LPAREN, - [61280] = 2, + [61162] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3339), 1, + ACTIONS(3331), 1, anon_sym_RBRACE, - [61287] = 2, + [61169] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3341), 1, + ACTIONS(3333), 1, anon_sym_GT, - [61294] = 2, + [61176] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3343), 1, - anon_sym_RBRACK, - [61301] = 2, + ACTIONS(3335), 1, + anon_sym_LBRACE, + [61183] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3345), 1, - anon_sym_effect, - [61308] = 2, + ACTIONS(1793), 1, + anon_sym_LBRACE, + [61190] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3347), 1, - anon_sym_RPAREN, - [61315] = 2, + ACTIONS(1564), 1, + sym__statement_break, + [61197] = 2, ACTIONS(298), 1, sym_line_comment, - ACTIONS(3349), 1, - sym__statement_break, + ACTIONS(3337), 1, + anon_sym_LBRACE, }; static const uint32_t ts_small_parse_table_map[] = { @@ -56404,14 +56355,14 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(526)] = 39596, [SMALL_STATE(527)] = 39627, [SMALL_STATE(528)] = 39685, - [SMALL_STATE(529)] = 39737, - [SMALL_STATE(530)] = 39795, + [SMALL_STATE(529)] = 39743, + [SMALL_STATE(530)] = 39801, [SMALL_STATE(531)] = 39853, [SMALL_STATE(532)] = 39911, [SMALL_STATE(533)] = 39969, [SMALL_STATE(534)] = 40027, - [SMALL_STATE(535)] = 40059, - [SMALL_STATE(536)] = 40117, + [SMALL_STATE(535)] = 40085, + [SMALL_STATE(536)] = 40143, [SMALL_STATE(537)] = 40175, [SMALL_STATE(538)] = 40233, [SMALL_STATE(539)] = 40291, @@ -56421,22 +56372,22 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(543)] = 40523, [SMALL_STATE(544)] = 40581, [SMALL_STATE(545)] = 40639, - [SMALL_STATE(546)] = 40691, - [SMALL_STATE(547)] = 40749, + [SMALL_STATE(546)] = 40697, + [SMALL_STATE(547)] = 40755, [SMALL_STATE(548)] = 40807, [SMALL_STATE(549)] = 40865, [SMALL_STATE(550)] = 40923, [SMALL_STATE(551)] = 40981, [SMALL_STATE(552)] = 41039, - [SMALL_STATE(553)] = 41091, - [SMALL_STATE(554)] = 41143, - [SMALL_STATE(555)] = 41201, + [SMALL_STATE(553)] = 41097, + [SMALL_STATE(554)] = 41155, + [SMALL_STATE(555)] = 41207, [SMALL_STATE(556)] = 41259, [SMALL_STATE(557)] = 41317, [SMALL_STATE(558)] = 41375, - [SMALL_STATE(559)] = 41427, - [SMALL_STATE(560)] = 41481, - [SMALL_STATE(561)] = 41539, + [SMALL_STATE(559)] = 41433, + [SMALL_STATE(560)] = 41491, + [SMALL_STATE(561)] = 41543, [SMALL_STATE(562)] = 41597, [SMALL_STATE(563)] = 41655, [SMALL_STATE(564)] = 41713, @@ -56470,15 +56421,15 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(592)] = 43325, [SMALL_STATE(593)] = 43383, [SMALL_STATE(594)] = 43441, - [SMALL_STATE(595)] = 43495, - [SMALL_STATE(596)] = 43553, - [SMALL_STATE(597)] = 43611, - [SMALL_STATE(598)] = 43669, - [SMALL_STATE(599)] = 43721, - [SMALL_STATE(600)] = 43779, - [SMALL_STATE(601)] = 43837, - [SMALL_STATE(602)] = 43895, - [SMALL_STATE(603)] = 43953, + [SMALL_STATE(595)] = 43499, + [SMALL_STATE(596)] = 43557, + [SMALL_STATE(597)] = 43615, + [SMALL_STATE(598)] = 43673, + [SMALL_STATE(599)] = 43727, + [SMALL_STATE(600)] = 43785, + [SMALL_STATE(601)] = 43843, + [SMALL_STATE(602)] = 43901, + [SMALL_STATE(603)] = 43959, [SMALL_STATE(604)] = 44011, [SMALL_STATE(605)] = 44069, [SMALL_STATE(606)] = 44127, @@ -56487,1155 +56438,1148 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(609)] = 44301, [SMALL_STATE(610)] = 44359, [SMALL_STATE(611)] = 44417, - [SMALL_STATE(612)] = 44446, - [SMALL_STATE(613)] = 44475, - [SMALL_STATE(614)] = 44530, - [SMALL_STATE(615)] = 44579, - [SMALL_STATE(616)] = 44628, - [SMALL_STATE(617)] = 44683, - [SMALL_STATE(618)] = 44712, - [SMALL_STATE(619)] = 44741, - [SMALL_STATE(620)] = 44796, - [SMALL_STATE(621)] = 44845, - [SMALL_STATE(622)] = 44874, - [SMALL_STATE(623)] = 44929, - [SMALL_STATE(624)] = 44968, - [SMALL_STATE(625)] = 45023, + [SMALL_STATE(612)] = 44472, + [SMALL_STATE(613)] = 44527, + [SMALL_STATE(614)] = 44566, + [SMALL_STATE(615)] = 44621, + [SMALL_STATE(616)] = 44676, + [SMALL_STATE(617)] = 44725, + [SMALL_STATE(618)] = 44754, + [SMALL_STATE(619)] = 44809, + [SMALL_STATE(620)] = 44858, + [SMALL_STATE(621)] = 44913, + [SMALL_STATE(622)] = 44942, + [SMALL_STATE(623)] = 44971, + [SMALL_STATE(624)] = 45020, + [SMALL_STATE(625)] = 45049, [SMALL_STATE(626)] = 45078, [SMALL_STATE(627)] = 45133, [SMALL_STATE(628)] = 45181, - [SMALL_STATE(629)] = 45229, - [SMALL_STATE(630)] = 45277, - [SMALL_STATE(631)] = 45322, - [SMALL_STATE(632)] = 45355, - [SMALL_STATE(633)] = 45388, - [SMALL_STATE(634)] = 45433, - [SMALL_STATE(635)] = 45478, - [SMALL_STATE(636)] = 45526, - [SMALL_STATE(637)] = 45574, - [SMALL_STATE(638)] = 45622, - [SMALL_STATE(639)] = 45670, - [SMALL_STATE(640)] = 45718, - [SMALL_STATE(641)] = 45766, - [SMALL_STATE(642)] = 45814, - [SMALL_STATE(643)] = 45862, - [SMALL_STATE(644)] = 45910, - [SMALL_STATE(645)] = 45937, - [SMALL_STATE(646)] = 45963, - [SMALL_STATE(647)] = 45989, - [SMALL_STATE(648)] = 46015, - [SMALL_STATE(649)] = 46036, - [SMALL_STATE(650)] = 46067, - [SMALL_STATE(651)] = 46088, - [SMALL_STATE(652)] = 46115, - [SMALL_STATE(653)] = 46142, - [SMALL_STATE(654)] = 46167, - [SMALL_STATE(655)] = 46188, - [SMALL_STATE(656)] = 46213, - [SMALL_STATE(657)] = 46238, - [SMALL_STATE(658)] = 46263, - [SMALL_STATE(659)] = 46283, - [SMALL_STATE(660)] = 46303, - [SMALL_STATE(661)] = 46323, - [SMALL_STATE(662)] = 46357, - [SMALL_STATE(663)] = 46379, - [SMALL_STATE(664)] = 46399, - [SMALL_STATE(665)] = 46419, - [SMALL_STATE(666)] = 46441, - [SMALL_STATE(667)] = 46461, - [SMALL_STATE(668)] = 46495, - [SMALL_STATE(669)] = 46529, - [SMALL_STATE(670)] = 46549, - [SMALL_STATE(671)] = 46571, - [SMALL_STATE(672)] = 46591, - [SMALL_STATE(673)] = 46611, - [SMALL_STATE(674)] = 46631, - [SMALL_STATE(675)] = 46653, - [SMALL_STATE(676)] = 46687, - [SMALL_STATE(677)] = 46707, - [SMALL_STATE(678)] = 46727, - [SMALL_STATE(679)] = 46747, - [SMALL_STATE(680)] = 46767, - [SMALL_STATE(681)] = 46787, - [SMALL_STATE(682)] = 46807, - [SMALL_STATE(683)] = 46827, - [SMALL_STATE(684)] = 46847, - [SMALL_STATE(685)] = 46881, - [SMALL_STATE(686)] = 46915, - [SMALL_STATE(687)] = 46937, - [SMALL_STATE(688)] = 46971, - [SMALL_STATE(689)] = 47005, - [SMALL_STATE(690)] = 47024, - [SMALL_STATE(691)] = 47043, - [SMALL_STATE(692)] = 47062, - [SMALL_STATE(693)] = 47081, - [SMALL_STATE(694)] = 47100, - [SMALL_STATE(695)] = 47119, - [SMALL_STATE(696)] = 47138, - [SMALL_STATE(697)] = 47157, - [SMALL_STATE(698)] = 47176, - [SMALL_STATE(699)] = 47195, - [SMALL_STATE(700)] = 47214, - [SMALL_STATE(701)] = 47233, - [SMALL_STATE(702)] = 47252, - [SMALL_STATE(703)] = 47271, - [SMALL_STATE(704)] = 47290, - [SMALL_STATE(705)] = 47309, - [SMALL_STATE(706)] = 47328, - [SMALL_STATE(707)] = 47355, - [SMALL_STATE(708)] = 47374, - [SMALL_STATE(709)] = 47393, - [SMALL_STATE(710)] = 47412, - [SMALL_STATE(711)] = 47431, - [SMALL_STATE(712)] = 47450, - [SMALL_STATE(713)] = 47469, - [SMALL_STATE(714)] = 47488, - [SMALL_STATE(715)] = 47507, - [SMALL_STATE(716)] = 47526, - [SMALL_STATE(717)] = 47545, - [SMALL_STATE(718)] = 47564, - [SMALL_STATE(719)] = 47583, - [SMALL_STATE(720)] = 47602, - [SMALL_STATE(721)] = 47621, - [SMALL_STATE(722)] = 47640, - [SMALL_STATE(723)] = 47659, - [SMALL_STATE(724)] = 47678, - [SMALL_STATE(725)] = 47697, - [SMALL_STATE(726)] = 47716, - [SMALL_STATE(727)] = 47735, - [SMALL_STATE(728)] = 47754, - [SMALL_STATE(729)] = 47773, - [SMALL_STATE(730)] = 47792, - [SMALL_STATE(731)] = 47811, - [SMALL_STATE(732)] = 47830, - [SMALL_STATE(733)] = 47849, - [SMALL_STATE(734)] = 47868, - [SMALL_STATE(735)] = 47887, - [SMALL_STATE(736)] = 47906, - [SMALL_STATE(737)] = 47925, - [SMALL_STATE(738)] = 47944, - [SMALL_STATE(739)] = 47963, - [SMALL_STATE(740)] = 47982, - [SMALL_STATE(741)] = 48001, - [SMALL_STATE(742)] = 48020, - [SMALL_STATE(743)] = 48039, - [SMALL_STATE(744)] = 48058, - [SMALL_STATE(745)] = 48077, - [SMALL_STATE(746)] = 48096, - [SMALL_STATE(747)] = 48115, - [SMALL_STATE(748)] = 48134, - [SMALL_STATE(749)] = 48153, - [SMALL_STATE(750)] = 48172, - [SMALL_STATE(751)] = 48191, - [SMALL_STATE(752)] = 48210, - [SMALL_STATE(753)] = 48229, - [SMALL_STATE(754)] = 48248, - [SMALL_STATE(755)] = 48267, - [SMALL_STATE(756)] = 48286, - [SMALL_STATE(757)] = 48311, - [SMALL_STATE(758)] = 48330, - [SMALL_STATE(759)] = 48349, - [SMALL_STATE(760)] = 48368, - [SMALL_STATE(761)] = 48402, - [SMALL_STATE(762)] = 48436, - [SMALL_STATE(763)] = 48470, - [SMALL_STATE(764)] = 48494, - [SMALL_STATE(765)] = 48518, - [SMALL_STATE(766)] = 48552, - [SMALL_STATE(767)] = 48586, - [SMALL_STATE(768)] = 48616, - [SMALL_STATE(769)] = 48650, - [SMALL_STATE(770)] = 48674, - [SMALL_STATE(771)] = 48708, - [SMALL_STATE(772)] = 48742, - [SMALL_STATE(773)] = 48776, - [SMALL_STATE(774)] = 48810, - [SMALL_STATE(775)] = 48832, - [SMALL_STATE(776)] = 48854, - [SMALL_STATE(777)] = 48888, - [SMALL_STATE(778)] = 48922, - [SMALL_STATE(779)] = 48956, - [SMALL_STATE(780)] = 48990, - [SMALL_STATE(781)] = 49024, - [SMALL_STATE(782)] = 49058, - [SMALL_STATE(783)] = 49082, - [SMALL_STATE(784)] = 49116, - [SMALL_STATE(785)] = 49150, - [SMALL_STATE(786)] = 49184, - [SMALL_STATE(787)] = 49218, - [SMALL_STATE(788)] = 49252, - [SMALL_STATE(789)] = 49286, - [SMALL_STATE(790)] = 49320, - [SMALL_STATE(791)] = 49344, - [SMALL_STATE(792)] = 49378, - [SMALL_STATE(793)] = 49412, - [SMALL_STATE(794)] = 49446, - [SMALL_STATE(795)] = 49480, - [SMALL_STATE(796)] = 49514, - [SMALL_STATE(797)] = 49548, - [SMALL_STATE(798)] = 49582, - [SMALL_STATE(799)] = 49616, - [SMALL_STATE(800)] = 49638, - [SMALL_STATE(801)] = 49660, - [SMALL_STATE(802)] = 49694, - [SMALL_STATE(803)] = 49728, - [SMALL_STATE(804)] = 49749, - [SMALL_STATE(805)] = 49770, - [SMALL_STATE(806)] = 49791, - [SMALL_STATE(807)] = 49810, - [SMALL_STATE(808)] = 49831, - [SMALL_STATE(809)] = 49848, - [SMALL_STATE(810)] = 49867, - [SMALL_STATE(811)] = 49888, - [SMALL_STATE(812)] = 49917, - [SMALL_STATE(813)] = 49952, - [SMALL_STATE(814)] = 49971, - [SMALL_STATE(815)] = 49992, - [SMALL_STATE(816)] = 50013, - [SMALL_STATE(817)] = 50040, - [SMALL_STATE(818)] = 50059, - [SMALL_STATE(819)] = 50088, - [SMALL_STATE(820)] = 50107, - [SMALL_STATE(821)] = 50136, - [SMALL_STATE(822)] = 50165, - [SMALL_STATE(823)] = 50194, - [SMALL_STATE(824)] = 50213, - [SMALL_STATE(825)] = 50242, - [SMALL_STATE(826)] = 50268, - [SMALL_STATE(827)] = 50286, - [SMALL_STATE(828)] = 50306, - [SMALL_STATE(829)] = 50332, - [SMALL_STATE(830)] = 50360, - [SMALL_STATE(831)] = 50386, - [SMALL_STATE(832)] = 50420, - [SMALL_STATE(833)] = 50446, - [SMALL_STATE(834)] = 50472, - [SMALL_STATE(835)] = 50498, - [SMALL_STATE(836)] = 50524, - [SMALL_STATE(837)] = 50550, - [SMALL_STATE(838)] = 50568, - [SMALL_STATE(839)] = 50586, - [SMALL_STATE(840)] = 50618, - [SMALL_STATE(841)] = 50633, - [SMALL_STATE(842)] = 50656, - [SMALL_STATE(843)] = 50679, - [SMALL_STATE(844)] = 50702, - [SMALL_STATE(845)] = 50725, - [SMALL_STATE(846)] = 50748, - [SMALL_STATE(847)] = 50771, - [SMALL_STATE(848)] = 50786, - [SMALL_STATE(849)] = 50809, - [SMALL_STATE(850)] = 50824, - [SMALL_STATE(851)] = 50847, - [SMALL_STATE(852)] = 50862, - [SMALL_STATE(853)] = 50885, - [SMALL_STATE(854)] = 50908, - [SMALL_STATE(855)] = 50931, - [SMALL_STATE(856)] = 50954, - [SMALL_STATE(857)] = 50977, - [SMALL_STATE(858)] = 51000, - [SMALL_STATE(859)] = 51023, - [SMALL_STATE(860)] = 51046, - [SMALL_STATE(861)] = 51069, - [SMALL_STATE(862)] = 51092, - [SMALL_STATE(863)] = 51111, - [SMALL_STATE(864)] = 51134, - [SMALL_STATE(865)] = 51153, - [SMALL_STATE(866)] = 51176, - [SMALL_STATE(867)] = 51199, - [SMALL_STATE(868)] = 51222, - [SMALL_STATE(869)] = 51245, - [SMALL_STATE(870)] = 51260, - [SMALL_STATE(871)] = 51283, - [SMALL_STATE(872)] = 51306, - [SMALL_STATE(873)] = 51321, - [SMALL_STATE(874)] = 51344, - [SMALL_STATE(875)] = 51367, - [SMALL_STATE(876)] = 51390, - [SMALL_STATE(877)] = 51413, - [SMALL_STATE(878)] = 51436, - [SMALL_STATE(879)] = 51459, - [SMALL_STATE(880)] = 51474, - [SMALL_STATE(881)] = 51497, - [SMALL_STATE(882)] = 51512, - [SMALL_STATE(883)] = 51535, - [SMALL_STATE(884)] = 51550, - [SMALL_STATE(885)] = 51565, - [SMALL_STATE(886)] = 51588, - [SMALL_STATE(887)] = 51603, - [SMALL_STATE(888)] = 51626, - [SMALL_STATE(889)] = 51649, - [SMALL_STATE(890)] = 51672, - [SMALL_STATE(891)] = 51695, - [SMALL_STATE(892)] = 51710, - [SMALL_STATE(893)] = 51725, - [SMALL_STATE(894)] = 51740, - [SMALL_STATE(895)] = 51763, - [SMALL_STATE(896)] = 51786, - [SMALL_STATE(897)] = 51809, - [SMALL_STATE(898)] = 51824, - [SMALL_STATE(899)] = 51847, - [SMALL_STATE(900)] = 51870, - [SMALL_STATE(901)] = 51893, - [SMALL_STATE(902)] = 51916, - [SMALL_STATE(903)] = 51939, - [SMALL_STATE(904)] = 51962, - [SMALL_STATE(905)] = 51985, - [SMALL_STATE(906)] = 52008, - [SMALL_STATE(907)] = 52023, - [SMALL_STATE(908)] = 52046, - [SMALL_STATE(909)] = 52061, - [SMALL_STATE(910)] = 52076, - [SMALL_STATE(911)] = 52099, - [SMALL_STATE(912)] = 52122, - [SMALL_STATE(913)] = 52137, - [SMALL_STATE(914)] = 52160, - [SMALL_STATE(915)] = 52175, - [SMALL_STATE(916)] = 52198, - [SMALL_STATE(917)] = 52221, - [SMALL_STATE(918)] = 52244, - [SMALL_STATE(919)] = 52267, - [SMALL_STATE(920)] = 52290, - [SMALL_STATE(921)] = 52313, - [SMALL_STATE(922)] = 52336, - [SMALL_STATE(923)] = 52363, - [SMALL_STATE(924)] = 52386, - [SMALL_STATE(925)] = 52409, - [SMALL_STATE(926)] = 52432, - [SMALL_STATE(927)] = 52455, - [SMALL_STATE(928)] = 52478, - [SMALL_STATE(929)] = 52501, - [SMALL_STATE(930)] = 52524, - [SMALL_STATE(931)] = 52547, - [SMALL_STATE(932)] = 52570, - [SMALL_STATE(933)] = 52593, - [SMALL_STATE(934)] = 52616, - [SMALL_STATE(935)] = 52639, - [SMALL_STATE(936)] = 52662, - [SMALL_STATE(937)] = 52685, - [SMALL_STATE(938)] = 52708, - [SMALL_STATE(939)] = 52731, - [SMALL_STATE(940)] = 52754, - [SMALL_STATE(941)] = 52768, - [SMALL_STATE(942)] = 52790, - [SMALL_STATE(943)] = 52811, - [SMALL_STATE(944)] = 52826, - [SMALL_STATE(945)] = 52841, - [SMALL_STATE(946)] = 52862, - [SMALL_STATE(947)] = 52877, - [SMALL_STATE(948)] = 52892, - [SMALL_STATE(949)] = 52907, - [SMALL_STATE(950)] = 52928, - [SMALL_STATE(951)] = 52949, - [SMALL_STATE(952)] = 52970, - [SMALL_STATE(953)] = 52985, - [SMALL_STATE(954)] = 53008, - [SMALL_STATE(955)] = 53023, - [SMALL_STATE(956)] = 53046, - [SMALL_STATE(957)] = 53069, - [SMALL_STATE(958)] = 53090, - [SMALL_STATE(959)] = 53105, - [SMALL_STATE(960)] = 53120, - [SMALL_STATE(961)] = 53135, - [SMALL_STATE(962)] = 53156, - [SMALL_STATE(963)] = 53171, - [SMALL_STATE(964)] = 53186, - [SMALL_STATE(965)] = 53201, - [SMALL_STATE(966)] = 53224, - [SMALL_STATE(967)] = 53239, - [SMALL_STATE(968)] = 53262, - [SMALL_STATE(969)] = 53283, - [SMALL_STATE(970)] = 53306, - [SMALL_STATE(971)] = 53321, - [SMALL_STATE(972)] = 53336, - [SMALL_STATE(973)] = 53358, - [SMALL_STATE(974)] = 53380, - [SMALL_STATE(975)] = 53402, - [SMALL_STATE(976)] = 53424, - [SMALL_STATE(977)] = 53446, - [SMALL_STATE(978)] = 53468, - [SMALL_STATE(979)] = 53484, - [SMALL_STATE(980)] = 53506, - [SMALL_STATE(981)] = 53518, - [SMALL_STATE(982)] = 53540, - [SMALL_STATE(983)] = 53562, - [SMALL_STATE(984)] = 53576, - [SMALL_STATE(985)] = 53596, - [SMALL_STATE(986)] = 53618, - [SMALL_STATE(987)] = 53640, - [SMALL_STATE(988)] = 53662, - [SMALL_STATE(989)] = 53684, - [SMALL_STATE(990)] = 53706, - [SMALL_STATE(991)] = 53728, - [SMALL_STATE(992)] = 53746, - [SMALL_STATE(993)] = 53768, - [SMALL_STATE(994)] = 53785, - [SMALL_STATE(995)] = 53802, - [SMALL_STATE(996)] = 53819, - [SMALL_STATE(997)] = 53836, - [SMALL_STATE(998)] = 53851, - [SMALL_STATE(999)] = 53870, - [SMALL_STATE(1000)] = 53887, - [SMALL_STATE(1001)] = 53904, - [SMALL_STATE(1002)] = 53919, - [SMALL_STATE(1003)] = 53934, - [SMALL_STATE(1004)] = 53949, - [SMALL_STATE(1005)] = 53968, - [SMALL_STATE(1006)] = 53985, - [SMALL_STATE(1007)] = 54000, - [SMALL_STATE(1008)] = 54017, - [SMALL_STATE(1009)] = 54034, - [SMALL_STATE(1010)] = 54049, - [SMALL_STATE(1011)] = 54066, - [SMALL_STATE(1012)] = 54083, - [SMALL_STATE(1013)] = 54102, - [SMALL_STATE(1014)] = 54121, - [SMALL_STATE(1015)] = 54138, - [SMALL_STATE(1016)] = 54157, - [SMALL_STATE(1017)] = 54176, - [SMALL_STATE(1018)] = 54195, - [SMALL_STATE(1019)] = 54212, - [SMALL_STATE(1020)] = 54231, - [SMALL_STATE(1021)] = 54250, - [SMALL_STATE(1022)] = 54267, - [SMALL_STATE(1023)] = 54286, - [SMALL_STATE(1024)] = 54305, - [SMALL_STATE(1025)] = 54324, - [SMALL_STATE(1026)] = 54343, - [SMALL_STATE(1027)] = 54362, - [SMALL_STATE(1028)] = 54377, - [SMALL_STATE(1029)] = 54394, - [SMALL_STATE(1030)] = 54409, - [SMALL_STATE(1031)] = 54424, - [SMALL_STATE(1032)] = 54439, - [SMALL_STATE(1033)] = 54456, - [SMALL_STATE(1034)] = 54475, - [SMALL_STATE(1035)] = 54490, - [SMALL_STATE(1036)] = 54507, - [SMALL_STATE(1037)] = 54524, - [SMALL_STATE(1038)] = 54539, - [SMALL_STATE(1039)] = 54556, - [SMALL_STATE(1040)] = 54573, - [SMALL_STATE(1041)] = 54588, - [SMALL_STATE(1042)] = 54603, - [SMALL_STATE(1043)] = 54620, - [SMALL_STATE(1044)] = 54637, - [SMALL_STATE(1045)] = 54654, - [SMALL_STATE(1046)] = 54671, - [SMALL_STATE(1047)] = 54688, - [SMALL_STATE(1048)] = 54703, - [SMALL_STATE(1049)] = 54720, - [SMALL_STATE(1050)] = 54739, - [SMALL_STATE(1051)] = 54756, - [SMALL_STATE(1052)] = 54773, - [SMALL_STATE(1053)] = 54790, - [SMALL_STATE(1054)] = 54809, - [SMALL_STATE(1055)] = 54826, - [SMALL_STATE(1056)] = 54843, - [SMALL_STATE(1057)] = 54860, - [SMALL_STATE(1058)] = 54879, - [SMALL_STATE(1059)] = 54896, - [SMALL_STATE(1060)] = 54913, - [SMALL_STATE(1061)] = 54930, - [SMALL_STATE(1062)] = 54949, - [SMALL_STATE(1063)] = 54968, - [SMALL_STATE(1064)] = 54985, - [SMALL_STATE(1065)] = 55002, - [SMALL_STATE(1066)] = 55019, - [SMALL_STATE(1067)] = 55038, - [SMALL_STATE(1068)] = 55057, - [SMALL_STATE(1069)] = 55074, - [SMALL_STATE(1070)] = 55091, - [SMALL_STATE(1071)] = 55108, - [SMALL_STATE(1072)] = 55118, - [SMALL_STATE(1073)] = 55132, - [SMALL_STATE(1074)] = 55142, - [SMALL_STATE(1075)] = 55156, - [SMALL_STATE(1076)] = 55166, - [SMALL_STATE(1077)] = 55176, - [SMALL_STATE(1078)] = 55186, - [SMALL_STATE(1079)] = 55196, - [SMALL_STATE(1080)] = 55206, - [SMALL_STATE(1081)] = 55222, - [SMALL_STATE(1082)] = 55236, - [SMALL_STATE(1083)] = 55252, - [SMALL_STATE(1084)] = 55262, - [SMALL_STATE(1085)] = 55278, - [SMALL_STATE(1086)] = 55288, - [SMALL_STATE(1087)] = 55304, - [SMALL_STATE(1088)] = 55314, - [SMALL_STATE(1089)] = 55328, - [SMALL_STATE(1090)] = 55342, - [SMALL_STATE(1091)] = 55358, - [SMALL_STATE(1092)] = 55372, - [SMALL_STATE(1093)] = 55386, - [SMALL_STATE(1094)] = 55400, - [SMALL_STATE(1095)] = 55412, - [SMALL_STATE(1096)] = 55426, - [SMALL_STATE(1097)] = 55442, - [SMALL_STATE(1098)] = 55456, - [SMALL_STATE(1099)] = 55466, - [SMALL_STATE(1100)] = 55480, - [SMALL_STATE(1101)] = 55494, - [SMALL_STATE(1102)] = 55508, - [SMALL_STATE(1103)] = 55524, - [SMALL_STATE(1104)] = 55540, - [SMALL_STATE(1105)] = 55556, - [SMALL_STATE(1106)] = 55566, - [SMALL_STATE(1107)] = 55580, - [SMALL_STATE(1108)] = 55590, - [SMALL_STATE(1109)] = 55604, - [SMALL_STATE(1110)] = 55620, - [SMALL_STATE(1111)] = 55636, - [SMALL_STATE(1112)] = 55646, - [SMALL_STATE(1113)] = 55662, - [SMALL_STATE(1114)] = 55676, - [SMALL_STATE(1115)] = 55690, - [SMALL_STATE(1116)] = 55704, - [SMALL_STATE(1117)] = 55718, - [SMALL_STATE(1118)] = 55728, - [SMALL_STATE(1119)] = 55744, - [SMALL_STATE(1120)] = 55754, - [SMALL_STATE(1121)] = 55770, - [SMALL_STATE(1122)] = 55783, - [SMALL_STATE(1123)] = 55796, - [SMALL_STATE(1124)] = 55809, - [SMALL_STATE(1125)] = 55822, - [SMALL_STATE(1126)] = 55835, - [SMALL_STATE(1127)] = 55848, - [SMALL_STATE(1128)] = 55861, - [SMALL_STATE(1129)] = 55874, - [SMALL_STATE(1130)] = 55887, - [SMALL_STATE(1131)] = 55900, - [SMALL_STATE(1132)] = 55913, - [SMALL_STATE(1133)] = 55926, - [SMALL_STATE(1134)] = 55939, - [SMALL_STATE(1135)] = 55952, - [SMALL_STATE(1136)] = 55965, - [SMALL_STATE(1137)] = 55978, - [SMALL_STATE(1138)] = 55991, - [SMALL_STATE(1139)] = 56004, - [SMALL_STATE(1140)] = 56017, - [SMALL_STATE(1141)] = 56030, - [SMALL_STATE(1142)] = 56043, - [SMALL_STATE(1143)] = 56056, - [SMALL_STATE(1144)] = 56069, - [SMALL_STATE(1145)] = 56082, - [SMALL_STATE(1146)] = 56095, - [SMALL_STATE(1147)] = 56108, - [SMALL_STATE(1148)] = 56121, - [SMALL_STATE(1149)] = 56134, - [SMALL_STATE(1150)] = 56147, - [SMALL_STATE(1151)] = 56160, - [SMALL_STATE(1152)] = 56169, - [SMALL_STATE(1153)] = 56182, - [SMALL_STATE(1154)] = 56195, - [SMALL_STATE(1155)] = 56208, - [SMALL_STATE(1156)] = 56221, - [SMALL_STATE(1157)] = 56234, - [SMALL_STATE(1158)] = 56247, - [SMALL_STATE(1159)] = 56260, - [SMALL_STATE(1160)] = 56273, - [SMALL_STATE(1161)] = 56284, - [SMALL_STATE(1162)] = 56297, - [SMALL_STATE(1163)] = 56308, - [SMALL_STATE(1164)] = 56321, - [SMALL_STATE(1165)] = 56332, - [SMALL_STATE(1166)] = 56343, - [SMALL_STATE(1167)] = 56356, - [SMALL_STATE(1168)] = 56369, - [SMALL_STATE(1169)] = 56382, - [SMALL_STATE(1170)] = 56395, - [SMALL_STATE(1171)] = 56404, - [SMALL_STATE(1172)] = 56417, - [SMALL_STATE(1173)] = 56426, - [SMALL_STATE(1174)] = 56439, - [SMALL_STATE(1175)] = 56452, - [SMALL_STATE(1176)] = 56465, - [SMALL_STATE(1177)] = 56478, - [SMALL_STATE(1178)] = 56491, - [SMALL_STATE(1179)] = 56504, - [SMALL_STATE(1180)] = 56517, - [SMALL_STATE(1181)] = 56526, - [SMALL_STATE(1182)] = 56539, - [SMALL_STATE(1183)] = 56550, - [SMALL_STATE(1184)] = 56563, - [SMALL_STATE(1185)] = 56574, - [SMALL_STATE(1186)] = 56587, - [SMALL_STATE(1187)] = 56600, - [SMALL_STATE(1188)] = 56613, - [SMALL_STATE(1189)] = 56626, - [SMALL_STATE(1190)] = 56637, - [SMALL_STATE(1191)] = 56646, - [SMALL_STATE(1192)] = 56659, - [SMALL_STATE(1193)] = 56672, - [SMALL_STATE(1194)] = 56685, - [SMALL_STATE(1195)] = 56698, - [SMALL_STATE(1196)] = 56711, - [SMALL_STATE(1197)] = 56724, - [SMALL_STATE(1198)] = 56737, - [SMALL_STATE(1199)] = 56750, - [SMALL_STATE(1200)] = 56763, - [SMALL_STATE(1201)] = 56776, - [SMALL_STATE(1202)] = 56789, - [SMALL_STATE(1203)] = 56798, - [SMALL_STATE(1204)] = 56811, - [SMALL_STATE(1205)] = 56822, - [SMALL_STATE(1206)] = 56835, - [SMALL_STATE(1207)] = 56848, - [SMALL_STATE(1208)] = 56861, - [SMALL_STATE(1209)] = 56874, - [SMALL_STATE(1210)] = 56887, - [SMALL_STATE(1211)] = 56900, - [SMALL_STATE(1212)] = 56913, - [SMALL_STATE(1213)] = 56926, - [SMALL_STATE(1214)] = 56939, - [SMALL_STATE(1215)] = 56952, - [SMALL_STATE(1216)] = 56963, - [SMALL_STATE(1217)] = 56976, - [SMALL_STATE(1218)] = 56989, - [SMALL_STATE(1219)] = 57002, - [SMALL_STATE(1220)] = 57015, - [SMALL_STATE(1221)] = 57026, - [SMALL_STATE(1222)] = 57039, - [SMALL_STATE(1223)] = 57052, - [SMALL_STATE(1224)] = 57065, - [SMALL_STATE(1225)] = 57078, - [SMALL_STATE(1226)] = 57091, - [SMALL_STATE(1227)] = 57104, - [SMALL_STATE(1228)] = 57117, - [SMALL_STATE(1229)] = 57128, - [SMALL_STATE(1230)] = 57141, - [SMALL_STATE(1231)] = 57154, - [SMALL_STATE(1232)] = 57163, - [SMALL_STATE(1233)] = 57174, - [SMALL_STATE(1234)] = 57187, - [SMALL_STATE(1235)] = 57200, - [SMALL_STATE(1236)] = 57213, - [SMALL_STATE(1237)] = 57226, - [SMALL_STATE(1238)] = 57239, - [SMALL_STATE(1239)] = 57252, - [SMALL_STATE(1240)] = 57265, - [SMALL_STATE(1241)] = 57278, - [SMALL_STATE(1242)] = 57291, - [SMALL_STATE(1243)] = 57304, - [SMALL_STATE(1244)] = 57317, - [SMALL_STATE(1245)] = 57330, - [SMALL_STATE(1246)] = 57343, - [SMALL_STATE(1247)] = 57356, - [SMALL_STATE(1248)] = 57369, - [SMALL_STATE(1249)] = 57382, - [SMALL_STATE(1250)] = 57395, - [SMALL_STATE(1251)] = 57404, - [SMALL_STATE(1252)] = 57417, - [SMALL_STATE(1253)] = 57430, - [SMALL_STATE(1254)] = 57443, - [SMALL_STATE(1255)] = 57456, - [SMALL_STATE(1256)] = 57469, - [SMALL_STATE(1257)] = 57482, - [SMALL_STATE(1258)] = 57495, - [SMALL_STATE(1259)] = 57508, - [SMALL_STATE(1260)] = 57521, - [SMALL_STATE(1261)] = 57534, - [SMALL_STATE(1262)] = 57547, - [SMALL_STATE(1263)] = 57558, - [SMALL_STATE(1264)] = 57571, - [SMALL_STATE(1265)] = 57584, - [SMALL_STATE(1266)] = 57597, - [SMALL_STATE(1267)] = 57610, - [SMALL_STATE(1268)] = 57623, - [SMALL_STATE(1269)] = 57634, - [SMALL_STATE(1270)] = 57647, - [SMALL_STATE(1271)] = 57657, - [SMALL_STATE(1272)] = 57667, - [SMALL_STATE(1273)] = 57677, - [SMALL_STATE(1274)] = 57685, - [SMALL_STATE(1275)] = 57693, - [SMALL_STATE(1276)] = 57701, - [SMALL_STATE(1277)] = 57709, - [SMALL_STATE(1278)] = 57719, - [SMALL_STATE(1279)] = 57729, - [SMALL_STATE(1280)] = 57739, - [SMALL_STATE(1281)] = 57747, - [SMALL_STATE(1282)] = 57755, - [SMALL_STATE(1283)] = 57765, - [SMALL_STATE(1284)] = 57775, - [SMALL_STATE(1285)] = 57783, - [SMALL_STATE(1286)] = 57791, - [SMALL_STATE(1287)] = 57799, - [SMALL_STATE(1288)] = 57809, - [SMALL_STATE(1289)] = 57819, - [SMALL_STATE(1290)] = 57829, - [SMALL_STATE(1291)] = 57839, - [SMALL_STATE(1292)] = 57847, - [SMALL_STATE(1293)] = 57857, - [SMALL_STATE(1294)] = 57867, - [SMALL_STATE(1295)] = 57877, - [SMALL_STATE(1296)] = 57887, - [SMALL_STATE(1297)] = 57895, - [SMALL_STATE(1298)] = 57905, - [SMALL_STATE(1299)] = 57915, - [SMALL_STATE(1300)] = 57925, - [SMALL_STATE(1301)] = 57935, - [SMALL_STATE(1302)] = 57945, - [SMALL_STATE(1303)] = 57955, - [SMALL_STATE(1304)] = 57965, - [SMALL_STATE(1305)] = 57975, - [SMALL_STATE(1306)] = 57985, - [SMALL_STATE(1307)] = 57993, - [SMALL_STATE(1308)] = 58001, - [SMALL_STATE(1309)] = 58009, - [SMALL_STATE(1310)] = 58019, - [SMALL_STATE(1311)] = 58027, - [SMALL_STATE(1312)] = 58037, - [SMALL_STATE(1313)] = 58045, - [SMALL_STATE(1314)] = 58053, - [SMALL_STATE(1315)] = 58061, - [SMALL_STATE(1316)] = 58071, - [SMALL_STATE(1317)] = 58081, - [SMALL_STATE(1318)] = 58091, - [SMALL_STATE(1319)] = 58101, - [SMALL_STATE(1320)] = 58109, - [SMALL_STATE(1321)] = 58119, - [SMALL_STATE(1322)] = 58129, - [SMALL_STATE(1323)] = 58139, - [SMALL_STATE(1324)] = 58149, - [SMALL_STATE(1325)] = 58157, - [SMALL_STATE(1326)] = 58165, - [SMALL_STATE(1327)] = 58175, - [SMALL_STATE(1328)] = 58185, - [SMALL_STATE(1329)] = 58195, - [SMALL_STATE(1330)] = 58203, - [SMALL_STATE(1331)] = 58213, - [SMALL_STATE(1332)] = 58223, - [SMALL_STATE(1333)] = 58233, - [SMALL_STATE(1334)] = 58243, - [SMALL_STATE(1335)] = 58253, - [SMALL_STATE(1336)] = 58263, - [SMALL_STATE(1337)] = 58273, - [SMALL_STATE(1338)] = 58281, - [SMALL_STATE(1339)] = 58291, - [SMALL_STATE(1340)] = 58301, - [SMALL_STATE(1341)] = 58309, - [SMALL_STATE(1342)] = 58319, - [SMALL_STATE(1343)] = 58329, - [SMALL_STATE(1344)] = 58339, - [SMALL_STATE(1345)] = 58349, - [SMALL_STATE(1346)] = 58357, - [SMALL_STATE(1347)] = 58367, - [SMALL_STATE(1348)] = 58375, - [SMALL_STATE(1349)] = 58385, - [SMALL_STATE(1350)] = 58393, - [SMALL_STATE(1351)] = 58403, - [SMALL_STATE(1352)] = 58411, - [SMALL_STATE(1353)] = 58421, - [SMALL_STATE(1354)] = 58431, - [SMALL_STATE(1355)] = 58441, - [SMALL_STATE(1356)] = 58451, - [SMALL_STATE(1357)] = 58461, - [SMALL_STATE(1358)] = 58471, - [SMALL_STATE(1359)] = 58481, - [SMALL_STATE(1360)] = 58491, - [SMALL_STATE(1361)] = 58501, - [SMALL_STATE(1362)] = 58511, - [SMALL_STATE(1363)] = 58519, - [SMALL_STATE(1364)] = 58527, - [SMALL_STATE(1365)] = 58537, - [SMALL_STATE(1366)] = 58545, - [SMALL_STATE(1367)] = 58555, - [SMALL_STATE(1368)] = 58565, - [SMALL_STATE(1369)] = 58575, - [SMALL_STATE(1370)] = 58585, - [SMALL_STATE(1371)] = 58592, - [SMALL_STATE(1372)] = 58599, - [SMALL_STATE(1373)] = 58606, - [SMALL_STATE(1374)] = 58613, - [SMALL_STATE(1375)] = 58620, - [SMALL_STATE(1376)] = 58627, - [SMALL_STATE(1377)] = 58634, - [SMALL_STATE(1378)] = 58641, - [SMALL_STATE(1379)] = 58648, - [SMALL_STATE(1380)] = 58655, - [SMALL_STATE(1381)] = 58662, - [SMALL_STATE(1382)] = 58669, - [SMALL_STATE(1383)] = 58676, - [SMALL_STATE(1384)] = 58683, - [SMALL_STATE(1385)] = 58690, - [SMALL_STATE(1386)] = 58697, - [SMALL_STATE(1387)] = 58704, - [SMALL_STATE(1388)] = 58711, - [SMALL_STATE(1389)] = 58718, - [SMALL_STATE(1390)] = 58725, - [SMALL_STATE(1391)] = 58732, - [SMALL_STATE(1392)] = 58739, - [SMALL_STATE(1393)] = 58746, - [SMALL_STATE(1394)] = 58753, - [SMALL_STATE(1395)] = 58760, - [SMALL_STATE(1396)] = 58767, - [SMALL_STATE(1397)] = 58774, - [SMALL_STATE(1398)] = 58781, - [SMALL_STATE(1399)] = 58788, - [SMALL_STATE(1400)] = 58795, - [SMALL_STATE(1401)] = 58802, - [SMALL_STATE(1402)] = 58809, - [SMALL_STATE(1403)] = 58816, - [SMALL_STATE(1404)] = 58823, - [SMALL_STATE(1405)] = 58830, - [SMALL_STATE(1406)] = 58837, - [SMALL_STATE(1407)] = 58844, - [SMALL_STATE(1408)] = 58851, - [SMALL_STATE(1409)] = 58858, - [SMALL_STATE(1410)] = 58865, - [SMALL_STATE(1411)] = 58872, - [SMALL_STATE(1412)] = 58879, - [SMALL_STATE(1413)] = 58886, - [SMALL_STATE(1414)] = 58893, - [SMALL_STATE(1415)] = 58900, - [SMALL_STATE(1416)] = 58907, - [SMALL_STATE(1417)] = 58914, - [SMALL_STATE(1418)] = 58921, - [SMALL_STATE(1419)] = 58928, - [SMALL_STATE(1420)] = 58935, - [SMALL_STATE(1421)] = 58942, - [SMALL_STATE(1422)] = 58949, - [SMALL_STATE(1423)] = 58956, - [SMALL_STATE(1424)] = 58963, - [SMALL_STATE(1425)] = 58970, - [SMALL_STATE(1426)] = 58977, - [SMALL_STATE(1427)] = 58984, - [SMALL_STATE(1428)] = 58991, - [SMALL_STATE(1429)] = 58998, - [SMALL_STATE(1430)] = 59005, - [SMALL_STATE(1431)] = 59012, - [SMALL_STATE(1432)] = 59019, - [SMALL_STATE(1433)] = 59026, - [SMALL_STATE(1434)] = 59033, - [SMALL_STATE(1435)] = 59040, - [SMALL_STATE(1436)] = 59047, - [SMALL_STATE(1437)] = 59054, - [SMALL_STATE(1438)] = 59061, - [SMALL_STATE(1439)] = 59068, - [SMALL_STATE(1440)] = 59075, - [SMALL_STATE(1441)] = 59082, - [SMALL_STATE(1442)] = 59089, - [SMALL_STATE(1443)] = 59096, - [SMALL_STATE(1444)] = 59103, - [SMALL_STATE(1445)] = 59110, - [SMALL_STATE(1446)] = 59117, - [SMALL_STATE(1447)] = 59124, - [SMALL_STATE(1448)] = 59131, - [SMALL_STATE(1449)] = 59138, - [SMALL_STATE(1450)] = 59145, - [SMALL_STATE(1451)] = 59152, - [SMALL_STATE(1452)] = 59159, - [SMALL_STATE(1453)] = 59166, - [SMALL_STATE(1454)] = 59173, - [SMALL_STATE(1455)] = 59180, - [SMALL_STATE(1456)] = 59187, - [SMALL_STATE(1457)] = 59194, - [SMALL_STATE(1458)] = 59201, - [SMALL_STATE(1459)] = 59208, - [SMALL_STATE(1460)] = 59215, - [SMALL_STATE(1461)] = 59222, - [SMALL_STATE(1462)] = 59229, - [SMALL_STATE(1463)] = 59236, - [SMALL_STATE(1464)] = 59243, - [SMALL_STATE(1465)] = 59250, - [SMALL_STATE(1466)] = 59257, - [SMALL_STATE(1467)] = 59264, - [SMALL_STATE(1468)] = 59271, - [SMALL_STATE(1469)] = 59278, - [SMALL_STATE(1470)] = 59285, - [SMALL_STATE(1471)] = 59292, - [SMALL_STATE(1472)] = 59299, - [SMALL_STATE(1473)] = 59306, - [SMALL_STATE(1474)] = 59313, - [SMALL_STATE(1475)] = 59320, - [SMALL_STATE(1476)] = 59327, - [SMALL_STATE(1477)] = 59334, - [SMALL_STATE(1478)] = 59341, - [SMALL_STATE(1479)] = 59348, - [SMALL_STATE(1480)] = 59355, - [SMALL_STATE(1481)] = 59362, - [SMALL_STATE(1482)] = 59369, - [SMALL_STATE(1483)] = 59376, - [SMALL_STATE(1484)] = 59383, - [SMALL_STATE(1485)] = 59390, - [SMALL_STATE(1486)] = 59397, - [SMALL_STATE(1487)] = 59404, - [SMALL_STATE(1488)] = 59411, - [SMALL_STATE(1489)] = 59418, - [SMALL_STATE(1490)] = 59425, - [SMALL_STATE(1491)] = 59432, - [SMALL_STATE(1492)] = 59439, - [SMALL_STATE(1493)] = 59446, - [SMALL_STATE(1494)] = 59453, - [SMALL_STATE(1495)] = 59460, - [SMALL_STATE(1496)] = 59467, - [SMALL_STATE(1497)] = 59474, - [SMALL_STATE(1498)] = 59481, - [SMALL_STATE(1499)] = 59488, - [SMALL_STATE(1500)] = 59495, - [SMALL_STATE(1501)] = 59502, - [SMALL_STATE(1502)] = 59509, - [SMALL_STATE(1503)] = 59516, - [SMALL_STATE(1504)] = 59523, - [SMALL_STATE(1505)] = 59530, - [SMALL_STATE(1506)] = 59537, - [SMALL_STATE(1507)] = 59544, - [SMALL_STATE(1508)] = 59551, - [SMALL_STATE(1509)] = 59558, - [SMALL_STATE(1510)] = 59565, - [SMALL_STATE(1511)] = 59572, - [SMALL_STATE(1512)] = 59579, - [SMALL_STATE(1513)] = 59586, - [SMALL_STATE(1514)] = 59593, - [SMALL_STATE(1515)] = 59600, - [SMALL_STATE(1516)] = 59607, - [SMALL_STATE(1517)] = 59614, - [SMALL_STATE(1518)] = 59621, - [SMALL_STATE(1519)] = 59628, - [SMALL_STATE(1520)] = 59635, - [SMALL_STATE(1521)] = 59642, - [SMALL_STATE(1522)] = 59649, - [SMALL_STATE(1523)] = 59656, - [SMALL_STATE(1524)] = 59663, - [SMALL_STATE(1525)] = 59670, - [SMALL_STATE(1526)] = 59677, - [SMALL_STATE(1527)] = 59684, - [SMALL_STATE(1528)] = 59691, - [SMALL_STATE(1529)] = 59698, - [SMALL_STATE(1530)] = 59705, - [SMALL_STATE(1531)] = 59712, - [SMALL_STATE(1532)] = 59719, - [SMALL_STATE(1533)] = 59726, - [SMALL_STATE(1534)] = 59733, - [SMALL_STATE(1535)] = 59740, - [SMALL_STATE(1536)] = 59747, - [SMALL_STATE(1537)] = 59754, - [SMALL_STATE(1538)] = 59761, - [SMALL_STATE(1539)] = 59768, - [SMALL_STATE(1540)] = 59775, - [SMALL_STATE(1541)] = 59782, - [SMALL_STATE(1542)] = 59789, - [SMALL_STATE(1543)] = 59796, - [SMALL_STATE(1544)] = 59803, - [SMALL_STATE(1545)] = 59810, - [SMALL_STATE(1546)] = 59817, - [SMALL_STATE(1547)] = 59824, - [SMALL_STATE(1548)] = 59831, - [SMALL_STATE(1549)] = 59838, - [SMALL_STATE(1550)] = 59845, - [SMALL_STATE(1551)] = 59852, - [SMALL_STATE(1552)] = 59859, - [SMALL_STATE(1553)] = 59866, - [SMALL_STATE(1554)] = 59873, - [SMALL_STATE(1555)] = 59880, - [SMALL_STATE(1556)] = 59887, - [SMALL_STATE(1557)] = 59894, - [SMALL_STATE(1558)] = 59901, - [SMALL_STATE(1559)] = 59908, - [SMALL_STATE(1560)] = 59915, - [SMALL_STATE(1561)] = 59922, - [SMALL_STATE(1562)] = 59929, - [SMALL_STATE(1563)] = 59936, - [SMALL_STATE(1564)] = 59943, - [SMALL_STATE(1565)] = 59950, - [SMALL_STATE(1566)] = 59957, - [SMALL_STATE(1567)] = 59964, - [SMALL_STATE(1568)] = 59971, - [SMALL_STATE(1569)] = 59978, - [SMALL_STATE(1570)] = 59985, - [SMALL_STATE(1571)] = 59992, - [SMALL_STATE(1572)] = 59999, - [SMALL_STATE(1573)] = 60006, - [SMALL_STATE(1574)] = 60013, - [SMALL_STATE(1575)] = 60020, - [SMALL_STATE(1576)] = 60027, - [SMALL_STATE(1577)] = 60034, - [SMALL_STATE(1578)] = 60041, - [SMALL_STATE(1579)] = 60048, - [SMALL_STATE(1580)] = 60055, - [SMALL_STATE(1581)] = 60062, - [SMALL_STATE(1582)] = 60069, - [SMALL_STATE(1583)] = 60076, - [SMALL_STATE(1584)] = 60083, - [SMALL_STATE(1585)] = 60090, - [SMALL_STATE(1586)] = 60097, - [SMALL_STATE(1587)] = 60104, - [SMALL_STATE(1588)] = 60111, - [SMALL_STATE(1589)] = 60118, - [SMALL_STATE(1590)] = 60125, - [SMALL_STATE(1591)] = 60132, - [SMALL_STATE(1592)] = 60139, - [SMALL_STATE(1593)] = 60146, - [SMALL_STATE(1594)] = 60153, - [SMALL_STATE(1595)] = 60160, - [SMALL_STATE(1596)] = 60167, - [SMALL_STATE(1597)] = 60174, - [SMALL_STATE(1598)] = 60181, - [SMALL_STATE(1599)] = 60188, - [SMALL_STATE(1600)] = 60195, - [SMALL_STATE(1601)] = 60202, - [SMALL_STATE(1602)] = 60209, - [SMALL_STATE(1603)] = 60216, - [SMALL_STATE(1604)] = 60223, - [SMALL_STATE(1605)] = 60230, - [SMALL_STATE(1606)] = 60237, - [SMALL_STATE(1607)] = 60244, - [SMALL_STATE(1608)] = 60251, - [SMALL_STATE(1609)] = 60258, - [SMALL_STATE(1610)] = 60265, - [SMALL_STATE(1611)] = 60272, - [SMALL_STATE(1612)] = 60279, - [SMALL_STATE(1613)] = 60286, - [SMALL_STATE(1614)] = 60293, - [SMALL_STATE(1615)] = 60300, - [SMALL_STATE(1616)] = 60307, - [SMALL_STATE(1617)] = 60314, - [SMALL_STATE(1618)] = 60321, - [SMALL_STATE(1619)] = 60328, - [SMALL_STATE(1620)] = 60335, - [SMALL_STATE(1621)] = 60342, - [SMALL_STATE(1622)] = 60349, - [SMALL_STATE(1623)] = 60356, - [SMALL_STATE(1624)] = 60363, - [SMALL_STATE(1625)] = 60370, - [SMALL_STATE(1626)] = 60377, - [SMALL_STATE(1627)] = 60384, - [SMALL_STATE(1628)] = 60391, - [SMALL_STATE(1629)] = 60398, - [SMALL_STATE(1630)] = 60405, - [SMALL_STATE(1631)] = 60412, - [SMALL_STATE(1632)] = 60419, - [SMALL_STATE(1633)] = 60426, - [SMALL_STATE(1634)] = 60433, - [SMALL_STATE(1635)] = 60440, - [SMALL_STATE(1636)] = 60447, - [SMALL_STATE(1637)] = 60454, - [SMALL_STATE(1638)] = 60461, - [SMALL_STATE(1639)] = 60468, - [SMALL_STATE(1640)] = 60475, - [SMALL_STATE(1641)] = 60482, - [SMALL_STATE(1642)] = 60489, - [SMALL_STATE(1643)] = 60496, - [SMALL_STATE(1644)] = 60503, - [SMALL_STATE(1645)] = 60510, - [SMALL_STATE(1646)] = 60517, - [SMALL_STATE(1647)] = 60524, - [SMALL_STATE(1648)] = 60531, - [SMALL_STATE(1649)] = 60538, - [SMALL_STATE(1650)] = 60545, - [SMALL_STATE(1651)] = 60552, - [SMALL_STATE(1652)] = 60559, - [SMALL_STATE(1653)] = 60566, - [SMALL_STATE(1654)] = 60573, - [SMALL_STATE(1655)] = 60580, - [SMALL_STATE(1656)] = 60587, - [SMALL_STATE(1657)] = 60594, - [SMALL_STATE(1658)] = 60601, - [SMALL_STATE(1659)] = 60608, - [SMALL_STATE(1660)] = 60615, - [SMALL_STATE(1661)] = 60622, - [SMALL_STATE(1662)] = 60629, - [SMALL_STATE(1663)] = 60636, - [SMALL_STATE(1664)] = 60643, - [SMALL_STATE(1665)] = 60650, - [SMALL_STATE(1666)] = 60657, - [SMALL_STATE(1667)] = 60664, - [SMALL_STATE(1668)] = 60671, - [SMALL_STATE(1669)] = 60678, - [SMALL_STATE(1670)] = 60685, - [SMALL_STATE(1671)] = 60692, - [SMALL_STATE(1672)] = 60699, - [SMALL_STATE(1673)] = 60706, - [SMALL_STATE(1674)] = 60713, - [SMALL_STATE(1675)] = 60720, - [SMALL_STATE(1676)] = 60727, - [SMALL_STATE(1677)] = 60734, - [SMALL_STATE(1678)] = 60741, - [SMALL_STATE(1679)] = 60748, - [SMALL_STATE(1680)] = 60755, - [SMALL_STATE(1681)] = 60762, - [SMALL_STATE(1682)] = 60769, - [SMALL_STATE(1683)] = 60776, - [SMALL_STATE(1684)] = 60783, - [SMALL_STATE(1685)] = 60790, - [SMALL_STATE(1686)] = 60797, - [SMALL_STATE(1687)] = 60804, - [SMALL_STATE(1688)] = 60811, - [SMALL_STATE(1689)] = 60818, - [SMALL_STATE(1690)] = 60825, - [SMALL_STATE(1691)] = 60832, - [SMALL_STATE(1692)] = 60839, - [SMALL_STATE(1693)] = 60846, - [SMALL_STATE(1694)] = 60853, - [SMALL_STATE(1695)] = 60860, - [SMALL_STATE(1696)] = 60867, - [SMALL_STATE(1697)] = 60874, - [SMALL_STATE(1698)] = 60881, - [SMALL_STATE(1699)] = 60888, - [SMALL_STATE(1700)] = 60895, - [SMALL_STATE(1701)] = 60902, - [SMALL_STATE(1702)] = 60909, - [SMALL_STATE(1703)] = 60916, - [SMALL_STATE(1704)] = 60923, - [SMALL_STATE(1705)] = 60930, - [SMALL_STATE(1706)] = 60937, - [SMALL_STATE(1707)] = 60944, - [SMALL_STATE(1708)] = 60951, - [SMALL_STATE(1709)] = 60958, - [SMALL_STATE(1710)] = 60965, - [SMALL_STATE(1711)] = 60972, - [SMALL_STATE(1712)] = 60979, - [SMALL_STATE(1713)] = 60986, - [SMALL_STATE(1714)] = 60993, - [SMALL_STATE(1715)] = 61000, - [SMALL_STATE(1716)] = 61007, - [SMALL_STATE(1717)] = 61014, - [SMALL_STATE(1718)] = 61021, - [SMALL_STATE(1719)] = 61028, - [SMALL_STATE(1720)] = 61035, - [SMALL_STATE(1721)] = 61042, - [SMALL_STATE(1722)] = 61049, - [SMALL_STATE(1723)] = 61056, - [SMALL_STATE(1724)] = 61063, - [SMALL_STATE(1725)] = 61070, - [SMALL_STATE(1726)] = 61077, - [SMALL_STATE(1727)] = 61084, - [SMALL_STATE(1728)] = 61091, - [SMALL_STATE(1729)] = 61098, - [SMALL_STATE(1730)] = 61105, - [SMALL_STATE(1731)] = 61112, - [SMALL_STATE(1732)] = 61119, - [SMALL_STATE(1733)] = 61126, - [SMALL_STATE(1734)] = 61133, - [SMALL_STATE(1735)] = 61140, - [SMALL_STATE(1736)] = 61147, - [SMALL_STATE(1737)] = 61154, - [SMALL_STATE(1738)] = 61161, - [SMALL_STATE(1739)] = 61168, - [SMALL_STATE(1740)] = 61175, - [SMALL_STATE(1741)] = 61182, - [SMALL_STATE(1742)] = 61189, - [SMALL_STATE(1743)] = 61196, - [SMALL_STATE(1744)] = 61203, - [SMALL_STATE(1745)] = 61210, - [SMALL_STATE(1746)] = 61217, - [SMALL_STATE(1747)] = 61224, - [SMALL_STATE(1748)] = 61231, - [SMALL_STATE(1749)] = 61238, - [SMALL_STATE(1750)] = 61245, - [SMALL_STATE(1751)] = 61252, - [SMALL_STATE(1752)] = 61259, - [SMALL_STATE(1753)] = 61266, - [SMALL_STATE(1754)] = 61273, - [SMALL_STATE(1755)] = 61280, - [SMALL_STATE(1756)] = 61287, - [SMALL_STATE(1757)] = 61294, - [SMALL_STATE(1758)] = 61301, - [SMALL_STATE(1759)] = 61308, - [SMALL_STATE(1760)] = 61315, + [SMALL_STATE(629)] = 45213, + [SMALL_STATE(630)] = 45261, + [SMALL_STATE(631)] = 45309, + [SMALL_STATE(632)] = 45342, + [SMALL_STATE(633)] = 45387, + [SMALL_STATE(634)] = 45414, + [SMALL_STATE(635)] = 45459, + [SMALL_STATE(636)] = 45504, + [SMALL_STATE(637)] = 45537, + [SMALL_STATE(638)] = 45585, + [SMALL_STATE(639)] = 45633, + [SMALL_STATE(640)] = 45681, + [SMALL_STATE(641)] = 45729, + [SMALL_STATE(642)] = 45759, + [SMALL_STATE(643)] = 45807, + [SMALL_STATE(644)] = 45855, + [SMALL_STATE(645)] = 45903, + [SMALL_STATE(646)] = 45951, + [SMALL_STATE(647)] = 45999, + [SMALL_STATE(648)] = 46026, + [SMALL_STATE(649)] = 46052, + [SMALL_STATE(650)] = 46078, + [SMALL_STATE(651)] = 46104, + [SMALL_STATE(652)] = 46135, + [SMALL_STATE(653)] = 46160, + [SMALL_STATE(654)] = 46185, + [SMALL_STATE(655)] = 46210, + [SMALL_STATE(656)] = 46231, + [SMALL_STATE(657)] = 46252, + [SMALL_STATE(658)] = 46273, + [SMALL_STATE(659)] = 46298, + [SMALL_STATE(660)] = 46318, + [SMALL_STATE(661)] = 46338, + [SMALL_STATE(662)] = 46372, + [SMALL_STATE(663)] = 46394, + [SMALL_STATE(664)] = 46414, + [SMALL_STATE(665)] = 46434, + [SMALL_STATE(666)] = 46468, + [SMALL_STATE(667)] = 46490, + [SMALL_STATE(668)] = 46510, + [SMALL_STATE(669)] = 46544, + [SMALL_STATE(670)] = 46564, + [SMALL_STATE(671)] = 46586, + [SMALL_STATE(672)] = 46606, + [SMALL_STATE(673)] = 46626, + [SMALL_STATE(674)] = 46646, + [SMALL_STATE(675)] = 46668, + [SMALL_STATE(676)] = 46702, + [SMALL_STATE(677)] = 46722, + [SMALL_STATE(678)] = 46742, + [SMALL_STATE(679)] = 46762, + [SMALL_STATE(680)] = 46782, + [SMALL_STATE(681)] = 46802, + [SMALL_STATE(682)] = 46822, + [SMALL_STATE(683)] = 46842, + [SMALL_STATE(684)] = 46862, + [SMALL_STATE(685)] = 46882, + [SMALL_STATE(686)] = 46916, + [SMALL_STATE(687)] = 46950, + [SMALL_STATE(688)] = 46984, + [SMALL_STATE(689)] = 47018, + [SMALL_STATE(690)] = 47037, + [SMALL_STATE(691)] = 47056, + [SMALL_STATE(692)] = 47075, + [SMALL_STATE(693)] = 47094, + [SMALL_STATE(694)] = 47113, + [SMALL_STATE(695)] = 47132, + [SMALL_STATE(696)] = 47151, + [SMALL_STATE(697)] = 47170, + [SMALL_STATE(698)] = 47189, + [SMALL_STATE(699)] = 47208, + [SMALL_STATE(700)] = 47227, + [SMALL_STATE(701)] = 47246, + [SMALL_STATE(702)] = 47265, + [SMALL_STATE(703)] = 47284, + [SMALL_STATE(704)] = 47303, + [SMALL_STATE(705)] = 47322, + [SMALL_STATE(706)] = 47341, + [SMALL_STATE(707)] = 47368, + [SMALL_STATE(708)] = 47387, + [SMALL_STATE(709)] = 47406, + [SMALL_STATE(710)] = 47425, + [SMALL_STATE(711)] = 47444, + [SMALL_STATE(712)] = 47463, + [SMALL_STATE(713)] = 47482, + [SMALL_STATE(714)] = 47501, + [SMALL_STATE(715)] = 47520, + [SMALL_STATE(716)] = 47539, + [SMALL_STATE(717)] = 47558, + [SMALL_STATE(718)] = 47577, + [SMALL_STATE(719)] = 47596, + [SMALL_STATE(720)] = 47615, + [SMALL_STATE(721)] = 47634, + [SMALL_STATE(722)] = 47653, + [SMALL_STATE(723)] = 47672, + [SMALL_STATE(724)] = 47691, + [SMALL_STATE(725)] = 47710, + [SMALL_STATE(726)] = 47729, + [SMALL_STATE(727)] = 47748, + [SMALL_STATE(728)] = 47767, + [SMALL_STATE(729)] = 47786, + [SMALL_STATE(730)] = 47805, + [SMALL_STATE(731)] = 47824, + [SMALL_STATE(732)] = 47843, + [SMALL_STATE(733)] = 47862, + [SMALL_STATE(734)] = 47881, + [SMALL_STATE(735)] = 47900, + [SMALL_STATE(736)] = 47919, + [SMALL_STATE(737)] = 47938, + [SMALL_STATE(738)] = 47957, + [SMALL_STATE(739)] = 47976, + [SMALL_STATE(740)] = 47995, + [SMALL_STATE(741)] = 48014, + [SMALL_STATE(742)] = 48033, + [SMALL_STATE(743)] = 48052, + [SMALL_STATE(744)] = 48071, + [SMALL_STATE(745)] = 48090, + [SMALL_STATE(746)] = 48109, + [SMALL_STATE(747)] = 48128, + [SMALL_STATE(748)] = 48147, + [SMALL_STATE(749)] = 48166, + [SMALL_STATE(750)] = 48185, + [SMALL_STATE(751)] = 48204, + [SMALL_STATE(752)] = 48223, + [SMALL_STATE(753)] = 48242, + [SMALL_STATE(754)] = 48261, + [SMALL_STATE(755)] = 48286, + [SMALL_STATE(756)] = 48305, + [SMALL_STATE(757)] = 48324, + [SMALL_STATE(758)] = 48343, + [SMALL_STATE(759)] = 48362, + [SMALL_STATE(760)] = 48381, + [SMALL_STATE(761)] = 48415, + [SMALL_STATE(762)] = 48449, + [SMALL_STATE(763)] = 48483, + [SMALL_STATE(764)] = 48517, + [SMALL_STATE(765)] = 48551, + [SMALL_STATE(766)] = 48575, + [SMALL_STATE(767)] = 48609, + [SMALL_STATE(768)] = 48643, + [SMALL_STATE(769)] = 48667, + [SMALL_STATE(770)] = 48701, + [SMALL_STATE(771)] = 48735, + [SMALL_STATE(772)] = 48769, + [SMALL_STATE(773)] = 48803, + [SMALL_STATE(774)] = 48837, + [SMALL_STATE(775)] = 48871, + [SMALL_STATE(776)] = 48905, + [SMALL_STATE(777)] = 48939, + [SMALL_STATE(778)] = 48973, + [SMALL_STATE(779)] = 49007, + [SMALL_STATE(780)] = 49031, + [SMALL_STATE(781)] = 49065, + [SMALL_STATE(782)] = 49099, + [SMALL_STATE(783)] = 49133, + [SMALL_STATE(784)] = 49167, + [SMALL_STATE(785)] = 49197, + [SMALL_STATE(786)] = 49231, + [SMALL_STATE(787)] = 49265, + [SMALL_STATE(788)] = 49289, + [SMALL_STATE(789)] = 49323, + [SMALL_STATE(790)] = 49357, + [SMALL_STATE(791)] = 49391, + [SMALL_STATE(792)] = 49425, + [SMALL_STATE(793)] = 49459, + [SMALL_STATE(794)] = 49493, + [SMALL_STATE(795)] = 49527, + [SMALL_STATE(796)] = 49561, + [SMALL_STATE(797)] = 49595, + [SMALL_STATE(798)] = 49617, + [SMALL_STATE(799)] = 49639, + [SMALL_STATE(800)] = 49673, + [SMALL_STATE(801)] = 49692, + [SMALL_STATE(802)] = 49711, + [SMALL_STATE(803)] = 49740, + [SMALL_STATE(804)] = 49761, + [SMALL_STATE(805)] = 49796, + [SMALL_STATE(806)] = 49823, + [SMALL_STATE(807)] = 49844, + [SMALL_STATE(808)] = 49873, + [SMALL_STATE(809)] = 49892, + [SMALL_STATE(810)] = 49913, + [SMALL_STATE(811)] = 49934, + [SMALL_STATE(812)] = 49953, + [SMALL_STATE(813)] = 49974, + [SMALL_STATE(814)] = 50003, + [SMALL_STATE(815)] = 50032, + [SMALL_STATE(816)] = 50061, + [SMALL_STATE(817)] = 50090, + [SMALL_STATE(818)] = 50109, + [SMALL_STATE(819)] = 50130, + [SMALL_STATE(820)] = 50151, + [SMALL_STATE(821)] = 50169, + [SMALL_STATE(822)] = 50187, + [SMALL_STATE(823)] = 50213, + [SMALL_STATE(824)] = 50239, + [SMALL_STATE(825)] = 50265, + [SMALL_STATE(826)] = 50283, + [SMALL_STATE(827)] = 50311, + [SMALL_STATE(828)] = 50337, + [SMALL_STATE(829)] = 50363, + [SMALL_STATE(830)] = 50397, + [SMALL_STATE(831)] = 50423, + [SMALL_STATE(832)] = 50449, + [SMALL_STATE(833)] = 50481, + [SMALL_STATE(834)] = 50507, + [SMALL_STATE(835)] = 50530, + [SMALL_STATE(836)] = 50545, + [SMALL_STATE(837)] = 50568, + [SMALL_STATE(838)] = 50591, + [SMALL_STATE(839)] = 50606, + [SMALL_STATE(840)] = 50629, + [SMALL_STATE(841)] = 50652, + [SMALL_STATE(842)] = 50675, + [SMALL_STATE(843)] = 50698, + [SMALL_STATE(844)] = 50721, + [SMALL_STATE(845)] = 50736, + [SMALL_STATE(846)] = 50759, + [SMALL_STATE(847)] = 50782, + [SMALL_STATE(848)] = 50797, + [SMALL_STATE(849)] = 50824, + [SMALL_STATE(850)] = 50847, + [SMALL_STATE(851)] = 50870, + [SMALL_STATE(852)] = 50893, + [SMALL_STATE(853)] = 50916, + [SMALL_STATE(854)] = 50939, + [SMALL_STATE(855)] = 50962, + [SMALL_STATE(856)] = 50985, + [SMALL_STATE(857)] = 51008, + [SMALL_STATE(858)] = 51027, + [SMALL_STATE(859)] = 51050, + [SMALL_STATE(860)] = 51069, + [SMALL_STATE(861)] = 51092, + [SMALL_STATE(862)] = 51115, + [SMALL_STATE(863)] = 51138, + [SMALL_STATE(864)] = 51161, + [SMALL_STATE(865)] = 51176, + [SMALL_STATE(866)] = 51199, + [SMALL_STATE(867)] = 51222, + [SMALL_STATE(868)] = 51245, + [SMALL_STATE(869)] = 51268, + [SMALL_STATE(870)] = 51283, + [SMALL_STATE(871)] = 51306, + [SMALL_STATE(872)] = 51329, + [SMALL_STATE(873)] = 51344, + [SMALL_STATE(874)] = 51367, + [SMALL_STATE(875)] = 51382, + [SMALL_STATE(876)] = 51405, + [SMALL_STATE(877)] = 51420, + [SMALL_STATE(878)] = 51435, + [SMALL_STATE(879)] = 51458, + [SMALL_STATE(880)] = 51481, + [SMALL_STATE(881)] = 51504, + [SMALL_STATE(882)] = 51527, + [SMALL_STATE(883)] = 51550, + [SMALL_STATE(884)] = 51573, + [SMALL_STATE(885)] = 51588, + [SMALL_STATE(886)] = 51603, + [SMALL_STATE(887)] = 51626, + [SMALL_STATE(888)] = 51641, + [SMALL_STATE(889)] = 51656, + [SMALL_STATE(890)] = 51679, + [SMALL_STATE(891)] = 51702, + [SMALL_STATE(892)] = 51725, + [SMALL_STATE(893)] = 51748, + [SMALL_STATE(894)] = 51771, + [SMALL_STATE(895)] = 51794, + [SMALL_STATE(896)] = 51817, + [SMALL_STATE(897)] = 51832, + [SMALL_STATE(898)] = 51855, + [SMALL_STATE(899)] = 51870, + [SMALL_STATE(900)] = 51885, + [SMALL_STATE(901)] = 51908, + [SMALL_STATE(902)] = 51931, + [SMALL_STATE(903)] = 51954, + [SMALL_STATE(904)] = 51969, + [SMALL_STATE(905)] = 51992, + [SMALL_STATE(906)] = 52015, + [SMALL_STATE(907)] = 52038, + [SMALL_STATE(908)] = 52061, + [SMALL_STATE(909)] = 52084, + [SMALL_STATE(910)] = 52107, + [SMALL_STATE(911)] = 52130, + [SMALL_STATE(912)] = 52153, + [SMALL_STATE(913)] = 52176, + [SMALL_STATE(914)] = 52199, + [SMALL_STATE(915)] = 52222, + [SMALL_STATE(916)] = 52245, + [SMALL_STATE(917)] = 52268, + [SMALL_STATE(918)] = 52283, + [SMALL_STATE(919)] = 52306, + [SMALL_STATE(920)] = 52329, + [SMALL_STATE(921)] = 52352, + [SMALL_STATE(922)] = 52375, + [SMALL_STATE(923)] = 52398, + [SMALL_STATE(924)] = 52421, + [SMALL_STATE(925)] = 52444, + [SMALL_STATE(926)] = 52467, + [SMALL_STATE(927)] = 52482, + [SMALL_STATE(928)] = 52505, + [SMALL_STATE(929)] = 52528, + [SMALL_STATE(930)] = 52551, + [SMALL_STATE(931)] = 52574, + [SMALL_STATE(932)] = 52597, + [SMALL_STATE(933)] = 52620, + [SMALL_STATE(934)] = 52643, + [SMALL_STATE(935)] = 52665, + [SMALL_STATE(936)] = 52679, + [SMALL_STATE(937)] = 52700, + [SMALL_STATE(938)] = 52723, + [SMALL_STATE(939)] = 52738, + [SMALL_STATE(940)] = 52753, + [SMALL_STATE(941)] = 52774, + [SMALL_STATE(942)] = 52789, + [SMALL_STATE(943)] = 52810, + [SMALL_STATE(944)] = 52831, + [SMALL_STATE(945)] = 52852, + [SMALL_STATE(946)] = 52867, + [SMALL_STATE(947)] = 52890, + [SMALL_STATE(948)] = 52905, + [SMALL_STATE(949)] = 52928, + [SMALL_STATE(950)] = 52943, + [SMALL_STATE(951)] = 52958, + [SMALL_STATE(952)] = 52973, + [SMALL_STATE(953)] = 52994, + [SMALL_STATE(954)] = 53009, + [SMALL_STATE(955)] = 53024, + [SMALL_STATE(956)] = 53039, + [SMALL_STATE(957)] = 53060, + [SMALL_STATE(958)] = 53075, + [SMALL_STATE(959)] = 53098, + [SMALL_STATE(960)] = 53121, + [SMALL_STATE(961)] = 53136, + [SMALL_STATE(962)] = 53151, + [SMALL_STATE(963)] = 53172, + [SMALL_STATE(964)] = 53195, + [SMALL_STATE(965)] = 53210, + [SMALL_STATE(966)] = 53225, + [SMALL_STATE(967)] = 53247, + [SMALL_STATE(968)] = 53269, + [SMALL_STATE(969)] = 53291, + [SMALL_STATE(970)] = 53303, + [SMALL_STATE(971)] = 53325, + [SMALL_STATE(972)] = 53347, + [SMALL_STATE(973)] = 53369, + [SMALL_STATE(974)] = 53391, + [SMALL_STATE(975)] = 53405, + [SMALL_STATE(976)] = 53427, + [SMALL_STATE(977)] = 53449, + [SMALL_STATE(978)] = 53471, + [SMALL_STATE(979)] = 53493, + [SMALL_STATE(980)] = 53515, + [SMALL_STATE(981)] = 53537, + [SMALL_STATE(982)] = 53559, + [SMALL_STATE(983)] = 53577, + [SMALL_STATE(984)] = 53597, + [SMALL_STATE(985)] = 53613, + [SMALL_STATE(986)] = 53635, + [SMALL_STATE(987)] = 53657, + [SMALL_STATE(988)] = 53674, + [SMALL_STATE(989)] = 53693, + [SMALL_STATE(990)] = 53710, + [SMALL_STATE(991)] = 53727, + [SMALL_STATE(992)] = 53744, + [SMALL_STATE(993)] = 53759, + [SMALL_STATE(994)] = 53776, + [SMALL_STATE(995)] = 53793, + [SMALL_STATE(996)] = 53810, + [SMALL_STATE(997)] = 53829, + [SMALL_STATE(998)] = 53846, + [SMALL_STATE(999)] = 53861, + [SMALL_STATE(1000)] = 53878, + [SMALL_STATE(1001)] = 53893, + [SMALL_STATE(1002)] = 53908, + [SMALL_STATE(1003)] = 53925, + [SMALL_STATE(1004)] = 53944, + [SMALL_STATE(1005)] = 53961, + [SMALL_STATE(1006)] = 53980, + [SMALL_STATE(1007)] = 53995, + [SMALL_STATE(1008)] = 54014, + [SMALL_STATE(1009)] = 54033, + [SMALL_STATE(1010)] = 54050, + [SMALL_STATE(1011)] = 54067, + [SMALL_STATE(1012)] = 54086, + [SMALL_STATE(1013)] = 54103, + [SMALL_STATE(1014)] = 54122, + [SMALL_STATE(1015)] = 54141, + [SMALL_STATE(1016)] = 54158, + [SMALL_STATE(1017)] = 54177, + [SMALL_STATE(1018)] = 54196, + [SMALL_STATE(1019)] = 54215, + [SMALL_STATE(1020)] = 54234, + [SMALL_STATE(1021)] = 54253, + [SMALL_STATE(1022)] = 54272, + [SMALL_STATE(1023)] = 54287, + [SMALL_STATE(1024)] = 54302, + [SMALL_STATE(1025)] = 54317, + [SMALL_STATE(1026)] = 54332, + [SMALL_STATE(1027)] = 54347, + [SMALL_STATE(1028)] = 54366, + [SMALL_STATE(1029)] = 54383, + [SMALL_STATE(1030)] = 54398, + [SMALL_STATE(1031)] = 54415, + [SMALL_STATE(1032)] = 54432, + [SMALL_STATE(1033)] = 54449, + [SMALL_STATE(1034)] = 54466, + [SMALL_STATE(1035)] = 54483, + [SMALL_STATE(1036)] = 54500, + [SMALL_STATE(1037)] = 54517, + [SMALL_STATE(1038)] = 54534, + [SMALL_STATE(1039)] = 54551, + [SMALL_STATE(1040)] = 54566, + [SMALL_STATE(1041)] = 54583, + [SMALL_STATE(1042)] = 54600, + [SMALL_STATE(1043)] = 54617, + [SMALL_STATE(1044)] = 54632, + [SMALL_STATE(1045)] = 54649, + [SMALL_STATE(1046)] = 54666, + [SMALL_STATE(1047)] = 54683, + [SMALL_STATE(1048)] = 54700, + [SMALL_STATE(1049)] = 54717, + [SMALL_STATE(1050)] = 54736, + [SMALL_STATE(1051)] = 54753, + [SMALL_STATE(1052)] = 54768, + [SMALL_STATE(1053)] = 54785, + [SMALL_STATE(1054)] = 54802, + [SMALL_STATE(1055)] = 54821, + [SMALL_STATE(1056)] = 54840, + [SMALL_STATE(1057)] = 54859, + [SMALL_STATE(1058)] = 54878, + [SMALL_STATE(1059)] = 54895, + [SMALL_STATE(1060)] = 54912, + [SMALL_STATE(1061)] = 54929, + [SMALL_STATE(1062)] = 54948, + [SMALL_STATE(1063)] = 54965, + [SMALL_STATE(1064)] = 54982, + [SMALL_STATE(1065)] = 54997, + [SMALL_STATE(1066)] = 55007, + [SMALL_STATE(1067)] = 55021, + [SMALL_STATE(1068)] = 55031, + [SMALL_STATE(1069)] = 55047, + [SMALL_STATE(1070)] = 55061, + [SMALL_STATE(1071)] = 55073, + [SMALL_STATE(1072)] = 55087, + [SMALL_STATE(1073)] = 55097, + [SMALL_STATE(1074)] = 55111, + [SMALL_STATE(1075)] = 55125, + [SMALL_STATE(1076)] = 55135, + [SMALL_STATE(1077)] = 55145, + [SMALL_STATE(1078)] = 55159, + [SMALL_STATE(1079)] = 55173, + [SMALL_STATE(1080)] = 55183, + [SMALL_STATE(1081)] = 55197, + [SMALL_STATE(1082)] = 55211, + [SMALL_STATE(1083)] = 55227, + [SMALL_STATE(1084)] = 55241, + [SMALL_STATE(1085)] = 55255, + [SMALL_STATE(1086)] = 55271, + [SMALL_STATE(1087)] = 55285, + [SMALL_STATE(1088)] = 55301, + [SMALL_STATE(1089)] = 55317, + [SMALL_STATE(1090)] = 55333, + [SMALL_STATE(1091)] = 55343, + [SMALL_STATE(1092)] = 55353, + [SMALL_STATE(1093)] = 55363, + [SMALL_STATE(1094)] = 55377, + [SMALL_STATE(1095)] = 55393, + [SMALL_STATE(1096)] = 55409, + [SMALL_STATE(1097)] = 55425, + [SMALL_STATE(1098)] = 55435, + [SMALL_STATE(1099)] = 55445, + [SMALL_STATE(1100)] = 55461, + [SMALL_STATE(1101)] = 55477, + [SMALL_STATE(1102)] = 55491, + [SMALL_STATE(1103)] = 55505, + [SMALL_STATE(1104)] = 55521, + [SMALL_STATE(1105)] = 55531, + [SMALL_STATE(1106)] = 55541, + [SMALL_STATE(1107)] = 55555, + [SMALL_STATE(1108)] = 55565, + [SMALL_STATE(1109)] = 55581, + [SMALL_STATE(1110)] = 55595, + [SMALL_STATE(1111)] = 55609, + [SMALL_STATE(1112)] = 55623, + [SMALL_STATE(1113)] = 55633, + [SMALL_STATE(1114)] = 55649, + [SMALL_STATE(1115)] = 55659, + [SMALL_STATE(1116)] = 55672, + [SMALL_STATE(1117)] = 55685, + [SMALL_STATE(1118)] = 55698, + [SMALL_STATE(1119)] = 55711, + [SMALL_STATE(1120)] = 55724, + [SMALL_STATE(1121)] = 55733, + [SMALL_STATE(1122)] = 55746, + [SMALL_STATE(1123)] = 55759, + [SMALL_STATE(1124)] = 55772, + [SMALL_STATE(1125)] = 55785, + [SMALL_STATE(1126)] = 55798, + [SMALL_STATE(1127)] = 55809, + [SMALL_STATE(1128)] = 55822, + [SMALL_STATE(1129)] = 55835, + [SMALL_STATE(1130)] = 55848, + [SMALL_STATE(1131)] = 55861, + [SMALL_STATE(1132)] = 55874, + [SMALL_STATE(1133)] = 55887, + [SMALL_STATE(1134)] = 55900, + [SMALL_STATE(1135)] = 55913, + [SMALL_STATE(1136)] = 55926, + [SMALL_STATE(1137)] = 55939, + [SMALL_STATE(1138)] = 55950, + [SMALL_STATE(1139)] = 55963, + [SMALL_STATE(1140)] = 55972, + [SMALL_STATE(1141)] = 55983, + [SMALL_STATE(1142)] = 55992, + [SMALL_STATE(1143)] = 56005, + [SMALL_STATE(1144)] = 56018, + [SMALL_STATE(1145)] = 56031, + [SMALL_STATE(1146)] = 56044, + [SMALL_STATE(1147)] = 56057, + [SMALL_STATE(1148)] = 56070, + [SMALL_STATE(1149)] = 56083, + [SMALL_STATE(1150)] = 56096, + [SMALL_STATE(1151)] = 56109, + [SMALL_STATE(1152)] = 56118, + [SMALL_STATE(1153)] = 56131, + [SMALL_STATE(1154)] = 56144, + [SMALL_STATE(1155)] = 56155, + [SMALL_STATE(1156)] = 56168, + [SMALL_STATE(1157)] = 56181, + [SMALL_STATE(1158)] = 56194, + [SMALL_STATE(1159)] = 56203, + [SMALL_STATE(1160)] = 56214, + [SMALL_STATE(1161)] = 56227, + [SMALL_STATE(1162)] = 56240, + [SMALL_STATE(1163)] = 56253, + [SMALL_STATE(1164)] = 56266, + [SMALL_STATE(1165)] = 56279, + [SMALL_STATE(1166)] = 56292, + [SMALL_STATE(1167)] = 56305, + [SMALL_STATE(1168)] = 56318, + [SMALL_STATE(1169)] = 56331, + [SMALL_STATE(1170)] = 56344, + [SMALL_STATE(1171)] = 56357, + [SMALL_STATE(1172)] = 56370, + [SMALL_STATE(1173)] = 56383, + [SMALL_STATE(1174)] = 56396, + [SMALL_STATE(1175)] = 56409, + [SMALL_STATE(1176)] = 56422, + [SMALL_STATE(1177)] = 56433, + [SMALL_STATE(1178)] = 56446, + [SMALL_STATE(1179)] = 56459, + [SMALL_STATE(1180)] = 56472, + [SMALL_STATE(1181)] = 56485, + [SMALL_STATE(1182)] = 56498, + [SMALL_STATE(1183)] = 56511, + [SMALL_STATE(1184)] = 56522, + [SMALL_STATE(1185)] = 56535, + [SMALL_STATE(1186)] = 56548, + [SMALL_STATE(1187)] = 56561, + [SMALL_STATE(1188)] = 56574, + [SMALL_STATE(1189)] = 56587, + [SMALL_STATE(1190)] = 56600, + [SMALL_STATE(1191)] = 56613, + [SMALL_STATE(1192)] = 56624, + [SMALL_STATE(1193)] = 56637, + [SMALL_STATE(1194)] = 56650, + [SMALL_STATE(1195)] = 56663, + [SMALL_STATE(1196)] = 56676, + [SMALL_STATE(1197)] = 56687, + [SMALL_STATE(1198)] = 56700, + [SMALL_STATE(1199)] = 56713, + [SMALL_STATE(1200)] = 56726, + [SMALL_STATE(1201)] = 56739, + [SMALL_STATE(1202)] = 56752, + [SMALL_STATE(1203)] = 56765, + [SMALL_STATE(1204)] = 56778, + [SMALL_STATE(1205)] = 56789, + [SMALL_STATE(1206)] = 56802, + [SMALL_STATE(1207)] = 56815, + [SMALL_STATE(1208)] = 56828, + [SMALL_STATE(1209)] = 56841, + [SMALL_STATE(1210)] = 56852, + [SMALL_STATE(1211)] = 56865, + [SMALL_STATE(1212)] = 56874, + [SMALL_STATE(1213)] = 56887, + [SMALL_STATE(1214)] = 56900, + [SMALL_STATE(1215)] = 56913, + [SMALL_STATE(1216)] = 56926, + [SMALL_STATE(1217)] = 56939, + [SMALL_STATE(1218)] = 56952, + [SMALL_STATE(1219)] = 56965, + [SMALL_STATE(1220)] = 56978, + [SMALL_STATE(1221)] = 56991, + [SMALL_STATE(1222)] = 57004, + [SMALL_STATE(1223)] = 57015, + [SMALL_STATE(1224)] = 57028, + [SMALL_STATE(1225)] = 57041, + [SMALL_STATE(1226)] = 57054, + [SMALL_STATE(1227)] = 57065, + [SMALL_STATE(1228)] = 57074, + [SMALL_STATE(1229)] = 57087, + [SMALL_STATE(1230)] = 57100, + [SMALL_STATE(1231)] = 57113, + [SMALL_STATE(1232)] = 57126, + [SMALL_STATE(1233)] = 57139, + [SMALL_STATE(1234)] = 57152, + [SMALL_STATE(1235)] = 57161, + [SMALL_STATE(1236)] = 57174, + [SMALL_STATE(1237)] = 57187, + [SMALL_STATE(1238)] = 57200, + [SMALL_STATE(1239)] = 57211, + [SMALL_STATE(1240)] = 57224, + [SMALL_STATE(1241)] = 57237, + [SMALL_STATE(1242)] = 57250, + [SMALL_STATE(1243)] = 57263, + [SMALL_STATE(1244)] = 57276, + [SMALL_STATE(1245)] = 57289, + [SMALL_STATE(1246)] = 57302, + [SMALL_STATE(1247)] = 57315, + [SMALL_STATE(1248)] = 57328, + [SMALL_STATE(1249)] = 57341, + [SMALL_STATE(1250)] = 57354, + [SMALL_STATE(1251)] = 57367, + [SMALL_STATE(1252)] = 57380, + [SMALL_STATE(1253)] = 57393, + [SMALL_STATE(1254)] = 57406, + [SMALL_STATE(1255)] = 57419, + [SMALL_STATE(1256)] = 57432, + [SMALL_STATE(1257)] = 57445, + [SMALL_STATE(1258)] = 57458, + [SMALL_STATE(1259)] = 57471, + [SMALL_STATE(1260)] = 57484, + [SMALL_STATE(1261)] = 57497, + [SMALL_STATE(1262)] = 57510, + [SMALL_STATE(1263)] = 57523, + [SMALL_STATE(1264)] = 57536, + [SMALL_STATE(1265)] = 57546, + [SMALL_STATE(1266)] = 57556, + [SMALL_STATE(1267)] = 57564, + [SMALL_STATE(1268)] = 57574, + [SMALL_STATE(1269)] = 57584, + [SMALL_STATE(1270)] = 57594, + [SMALL_STATE(1271)] = 57602, + [SMALL_STATE(1272)] = 57612, + [SMALL_STATE(1273)] = 57620, + [SMALL_STATE(1274)] = 57628, + [SMALL_STATE(1275)] = 57638, + [SMALL_STATE(1276)] = 57648, + [SMALL_STATE(1277)] = 57658, + [SMALL_STATE(1278)] = 57666, + [SMALL_STATE(1279)] = 57674, + [SMALL_STATE(1280)] = 57682, + [SMALL_STATE(1281)] = 57692, + [SMALL_STATE(1282)] = 57700, + [SMALL_STATE(1283)] = 57710, + [SMALL_STATE(1284)] = 57718, + [SMALL_STATE(1285)] = 57726, + [SMALL_STATE(1286)] = 57736, + [SMALL_STATE(1287)] = 57746, + [SMALL_STATE(1288)] = 57756, + [SMALL_STATE(1289)] = 57764, + [SMALL_STATE(1290)] = 57774, + [SMALL_STATE(1291)] = 57784, + [SMALL_STATE(1292)] = 57794, + [SMALL_STATE(1293)] = 57804, + [SMALL_STATE(1294)] = 57814, + [SMALL_STATE(1295)] = 57824, + [SMALL_STATE(1296)] = 57832, + [SMALL_STATE(1297)] = 57842, + [SMALL_STATE(1298)] = 57852, + [SMALL_STATE(1299)] = 57860, + [SMALL_STATE(1300)] = 57870, + [SMALL_STATE(1301)] = 57880, + [SMALL_STATE(1302)] = 57890, + [SMALL_STATE(1303)] = 57900, + [SMALL_STATE(1304)] = 57908, + [SMALL_STATE(1305)] = 57916, + [SMALL_STATE(1306)] = 57924, + [SMALL_STATE(1307)] = 57934, + [SMALL_STATE(1308)] = 57944, + [SMALL_STATE(1309)] = 57954, + [SMALL_STATE(1310)] = 57962, + [SMALL_STATE(1311)] = 57972, + [SMALL_STATE(1312)] = 57982, + [SMALL_STATE(1313)] = 57990, + [SMALL_STATE(1314)] = 57998, + [SMALL_STATE(1315)] = 58008, + [SMALL_STATE(1316)] = 58018, + [SMALL_STATE(1317)] = 58028, + [SMALL_STATE(1318)] = 58038, + [SMALL_STATE(1319)] = 58046, + [SMALL_STATE(1320)] = 58056, + [SMALL_STATE(1321)] = 58066, + [SMALL_STATE(1322)] = 58076, + [SMALL_STATE(1323)] = 58086, + [SMALL_STATE(1324)] = 58094, + [SMALL_STATE(1325)] = 58102, + [SMALL_STATE(1326)] = 58112, + [SMALL_STATE(1327)] = 58122, + [SMALL_STATE(1328)] = 58132, + [SMALL_STATE(1329)] = 58142, + [SMALL_STATE(1330)] = 58150, + [SMALL_STATE(1331)] = 58160, + [SMALL_STATE(1332)] = 58170, + [SMALL_STATE(1333)] = 58180, + [SMALL_STATE(1334)] = 58190, + [SMALL_STATE(1335)] = 58200, + [SMALL_STATE(1336)] = 58210, + [SMALL_STATE(1337)] = 58218, + [SMALL_STATE(1338)] = 58228, + [SMALL_STATE(1339)] = 58238, + [SMALL_STATE(1340)] = 58246, + [SMALL_STATE(1341)] = 58256, + [SMALL_STATE(1342)] = 58264, + [SMALL_STATE(1343)] = 58274, + [SMALL_STATE(1344)] = 58282, + [SMALL_STATE(1345)] = 58292, + [SMALL_STATE(1346)] = 58302, + [SMALL_STATE(1347)] = 58312, + [SMALL_STATE(1348)] = 58320, + [SMALL_STATE(1349)] = 58330, + [SMALL_STATE(1350)] = 58340, + [SMALL_STATE(1351)] = 58350, + [SMALL_STATE(1352)] = 58360, + [SMALL_STATE(1353)] = 58370, + [SMALL_STATE(1354)] = 58380, + [SMALL_STATE(1355)] = 58388, + [SMALL_STATE(1356)] = 58398, + [SMALL_STATE(1357)] = 58408, + [SMALL_STATE(1358)] = 58418, + [SMALL_STATE(1359)] = 58428, + [SMALL_STATE(1360)] = 58438, + [SMALL_STATE(1361)] = 58446, + [SMALL_STATE(1362)] = 58456, + [SMALL_STATE(1363)] = 58464, + [SMALL_STATE(1364)] = 58474, + [SMALL_STATE(1365)] = 58481, + [SMALL_STATE(1366)] = 58488, + [SMALL_STATE(1367)] = 58495, + [SMALL_STATE(1368)] = 58502, + [SMALL_STATE(1369)] = 58509, + [SMALL_STATE(1370)] = 58516, + [SMALL_STATE(1371)] = 58523, + [SMALL_STATE(1372)] = 58530, + [SMALL_STATE(1373)] = 58537, + [SMALL_STATE(1374)] = 58544, + [SMALL_STATE(1375)] = 58551, + [SMALL_STATE(1376)] = 58558, + [SMALL_STATE(1377)] = 58565, + [SMALL_STATE(1378)] = 58572, + [SMALL_STATE(1379)] = 58579, + [SMALL_STATE(1380)] = 58586, + [SMALL_STATE(1381)] = 58593, + [SMALL_STATE(1382)] = 58600, + [SMALL_STATE(1383)] = 58607, + [SMALL_STATE(1384)] = 58614, + [SMALL_STATE(1385)] = 58621, + [SMALL_STATE(1386)] = 58628, + [SMALL_STATE(1387)] = 58635, + [SMALL_STATE(1388)] = 58642, + [SMALL_STATE(1389)] = 58649, + [SMALL_STATE(1390)] = 58656, + [SMALL_STATE(1391)] = 58663, + [SMALL_STATE(1392)] = 58670, + [SMALL_STATE(1393)] = 58677, + [SMALL_STATE(1394)] = 58684, + [SMALL_STATE(1395)] = 58691, + [SMALL_STATE(1396)] = 58698, + [SMALL_STATE(1397)] = 58705, + [SMALL_STATE(1398)] = 58712, + [SMALL_STATE(1399)] = 58719, + [SMALL_STATE(1400)] = 58726, + [SMALL_STATE(1401)] = 58733, + [SMALL_STATE(1402)] = 58740, + [SMALL_STATE(1403)] = 58747, + [SMALL_STATE(1404)] = 58754, + [SMALL_STATE(1405)] = 58761, + [SMALL_STATE(1406)] = 58768, + [SMALL_STATE(1407)] = 58775, + [SMALL_STATE(1408)] = 58782, + [SMALL_STATE(1409)] = 58789, + [SMALL_STATE(1410)] = 58796, + [SMALL_STATE(1411)] = 58803, + [SMALL_STATE(1412)] = 58810, + [SMALL_STATE(1413)] = 58817, + [SMALL_STATE(1414)] = 58824, + [SMALL_STATE(1415)] = 58831, + [SMALL_STATE(1416)] = 58838, + [SMALL_STATE(1417)] = 58845, + [SMALL_STATE(1418)] = 58852, + [SMALL_STATE(1419)] = 58859, + [SMALL_STATE(1420)] = 58866, + [SMALL_STATE(1421)] = 58873, + [SMALL_STATE(1422)] = 58880, + [SMALL_STATE(1423)] = 58887, + [SMALL_STATE(1424)] = 58894, + [SMALL_STATE(1425)] = 58901, + [SMALL_STATE(1426)] = 58908, + [SMALL_STATE(1427)] = 58915, + [SMALL_STATE(1428)] = 58922, + [SMALL_STATE(1429)] = 58929, + [SMALL_STATE(1430)] = 58936, + [SMALL_STATE(1431)] = 58943, + [SMALL_STATE(1432)] = 58950, + [SMALL_STATE(1433)] = 58957, + [SMALL_STATE(1434)] = 58964, + [SMALL_STATE(1435)] = 58971, + [SMALL_STATE(1436)] = 58978, + [SMALL_STATE(1437)] = 58985, + [SMALL_STATE(1438)] = 58992, + [SMALL_STATE(1439)] = 58999, + [SMALL_STATE(1440)] = 59006, + [SMALL_STATE(1441)] = 59013, + [SMALL_STATE(1442)] = 59020, + [SMALL_STATE(1443)] = 59027, + [SMALL_STATE(1444)] = 59034, + [SMALL_STATE(1445)] = 59041, + [SMALL_STATE(1446)] = 59048, + [SMALL_STATE(1447)] = 59055, + [SMALL_STATE(1448)] = 59062, + [SMALL_STATE(1449)] = 59069, + [SMALL_STATE(1450)] = 59076, + [SMALL_STATE(1451)] = 59083, + [SMALL_STATE(1452)] = 59090, + [SMALL_STATE(1453)] = 59097, + [SMALL_STATE(1454)] = 59104, + [SMALL_STATE(1455)] = 59111, + [SMALL_STATE(1456)] = 59118, + [SMALL_STATE(1457)] = 59125, + [SMALL_STATE(1458)] = 59132, + [SMALL_STATE(1459)] = 59139, + [SMALL_STATE(1460)] = 59146, + [SMALL_STATE(1461)] = 59153, + [SMALL_STATE(1462)] = 59160, + [SMALL_STATE(1463)] = 59167, + [SMALL_STATE(1464)] = 59174, + [SMALL_STATE(1465)] = 59181, + [SMALL_STATE(1466)] = 59188, + [SMALL_STATE(1467)] = 59195, + [SMALL_STATE(1468)] = 59202, + [SMALL_STATE(1469)] = 59209, + [SMALL_STATE(1470)] = 59216, + [SMALL_STATE(1471)] = 59223, + [SMALL_STATE(1472)] = 59230, + [SMALL_STATE(1473)] = 59237, + [SMALL_STATE(1474)] = 59244, + [SMALL_STATE(1475)] = 59251, + [SMALL_STATE(1476)] = 59258, + [SMALL_STATE(1477)] = 59265, + [SMALL_STATE(1478)] = 59272, + [SMALL_STATE(1479)] = 59279, + [SMALL_STATE(1480)] = 59286, + [SMALL_STATE(1481)] = 59293, + [SMALL_STATE(1482)] = 59300, + [SMALL_STATE(1483)] = 59307, + [SMALL_STATE(1484)] = 59314, + [SMALL_STATE(1485)] = 59321, + [SMALL_STATE(1486)] = 59328, + [SMALL_STATE(1487)] = 59335, + [SMALL_STATE(1488)] = 59342, + [SMALL_STATE(1489)] = 59349, + [SMALL_STATE(1490)] = 59356, + [SMALL_STATE(1491)] = 59363, + [SMALL_STATE(1492)] = 59370, + [SMALL_STATE(1493)] = 59377, + [SMALL_STATE(1494)] = 59384, + [SMALL_STATE(1495)] = 59391, + [SMALL_STATE(1496)] = 59398, + [SMALL_STATE(1497)] = 59405, + [SMALL_STATE(1498)] = 59412, + [SMALL_STATE(1499)] = 59419, + [SMALL_STATE(1500)] = 59426, + [SMALL_STATE(1501)] = 59433, + [SMALL_STATE(1502)] = 59440, + [SMALL_STATE(1503)] = 59447, + [SMALL_STATE(1504)] = 59454, + [SMALL_STATE(1505)] = 59461, + [SMALL_STATE(1506)] = 59468, + [SMALL_STATE(1507)] = 59475, + [SMALL_STATE(1508)] = 59482, + [SMALL_STATE(1509)] = 59489, + [SMALL_STATE(1510)] = 59496, + [SMALL_STATE(1511)] = 59503, + [SMALL_STATE(1512)] = 59510, + [SMALL_STATE(1513)] = 59517, + [SMALL_STATE(1514)] = 59524, + [SMALL_STATE(1515)] = 59531, + [SMALL_STATE(1516)] = 59538, + [SMALL_STATE(1517)] = 59545, + [SMALL_STATE(1518)] = 59552, + [SMALL_STATE(1519)] = 59559, + [SMALL_STATE(1520)] = 59566, + [SMALL_STATE(1521)] = 59573, + [SMALL_STATE(1522)] = 59580, + [SMALL_STATE(1523)] = 59587, + [SMALL_STATE(1524)] = 59594, + [SMALL_STATE(1525)] = 59601, + [SMALL_STATE(1526)] = 59608, + [SMALL_STATE(1527)] = 59615, + [SMALL_STATE(1528)] = 59622, + [SMALL_STATE(1529)] = 59629, + [SMALL_STATE(1530)] = 59636, + [SMALL_STATE(1531)] = 59643, + [SMALL_STATE(1532)] = 59650, + [SMALL_STATE(1533)] = 59657, + [SMALL_STATE(1534)] = 59664, + [SMALL_STATE(1535)] = 59671, + [SMALL_STATE(1536)] = 59678, + [SMALL_STATE(1537)] = 59685, + [SMALL_STATE(1538)] = 59692, + [SMALL_STATE(1539)] = 59699, + [SMALL_STATE(1540)] = 59706, + [SMALL_STATE(1541)] = 59713, + [SMALL_STATE(1542)] = 59720, + [SMALL_STATE(1543)] = 59727, + [SMALL_STATE(1544)] = 59734, + [SMALL_STATE(1545)] = 59741, + [SMALL_STATE(1546)] = 59748, + [SMALL_STATE(1547)] = 59755, + [SMALL_STATE(1548)] = 59762, + [SMALL_STATE(1549)] = 59769, + [SMALL_STATE(1550)] = 59776, + [SMALL_STATE(1551)] = 59783, + [SMALL_STATE(1552)] = 59790, + [SMALL_STATE(1553)] = 59797, + [SMALL_STATE(1554)] = 59804, + [SMALL_STATE(1555)] = 59811, + [SMALL_STATE(1556)] = 59818, + [SMALL_STATE(1557)] = 59825, + [SMALL_STATE(1558)] = 59832, + [SMALL_STATE(1559)] = 59839, + [SMALL_STATE(1560)] = 59846, + [SMALL_STATE(1561)] = 59853, + [SMALL_STATE(1562)] = 59860, + [SMALL_STATE(1563)] = 59867, + [SMALL_STATE(1564)] = 59874, + [SMALL_STATE(1565)] = 59881, + [SMALL_STATE(1566)] = 59888, + [SMALL_STATE(1567)] = 59895, + [SMALL_STATE(1568)] = 59902, + [SMALL_STATE(1569)] = 59909, + [SMALL_STATE(1570)] = 59916, + [SMALL_STATE(1571)] = 59923, + [SMALL_STATE(1572)] = 59930, + [SMALL_STATE(1573)] = 59937, + [SMALL_STATE(1574)] = 59944, + [SMALL_STATE(1575)] = 59951, + [SMALL_STATE(1576)] = 59958, + [SMALL_STATE(1577)] = 59965, + [SMALL_STATE(1578)] = 59972, + [SMALL_STATE(1579)] = 59979, + [SMALL_STATE(1580)] = 59986, + [SMALL_STATE(1581)] = 59993, + [SMALL_STATE(1582)] = 60000, + [SMALL_STATE(1583)] = 60007, + [SMALL_STATE(1584)] = 60014, + [SMALL_STATE(1585)] = 60021, + [SMALL_STATE(1586)] = 60028, + [SMALL_STATE(1587)] = 60035, + [SMALL_STATE(1588)] = 60042, + [SMALL_STATE(1589)] = 60049, + [SMALL_STATE(1590)] = 60056, + [SMALL_STATE(1591)] = 60063, + [SMALL_STATE(1592)] = 60070, + [SMALL_STATE(1593)] = 60077, + [SMALL_STATE(1594)] = 60084, + [SMALL_STATE(1595)] = 60091, + [SMALL_STATE(1596)] = 60098, + [SMALL_STATE(1597)] = 60105, + [SMALL_STATE(1598)] = 60112, + [SMALL_STATE(1599)] = 60119, + [SMALL_STATE(1600)] = 60126, + [SMALL_STATE(1601)] = 60133, + [SMALL_STATE(1602)] = 60140, + [SMALL_STATE(1603)] = 60147, + [SMALL_STATE(1604)] = 60154, + [SMALL_STATE(1605)] = 60161, + [SMALL_STATE(1606)] = 60168, + [SMALL_STATE(1607)] = 60175, + [SMALL_STATE(1608)] = 60182, + [SMALL_STATE(1609)] = 60189, + [SMALL_STATE(1610)] = 60196, + [SMALL_STATE(1611)] = 60203, + [SMALL_STATE(1612)] = 60210, + [SMALL_STATE(1613)] = 60217, + [SMALL_STATE(1614)] = 60224, + [SMALL_STATE(1615)] = 60231, + [SMALL_STATE(1616)] = 60238, + [SMALL_STATE(1617)] = 60245, + [SMALL_STATE(1618)] = 60252, + [SMALL_STATE(1619)] = 60259, + [SMALL_STATE(1620)] = 60266, + [SMALL_STATE(1621)] = 60273, + [SMALL_STATE(1622)] = 60280, + [SMALL_STATE(1623)] = 60287, + [SMALL_STATE(1624)] = 60294, + [SMALL_STATE(1625)] = 60301, + [SMALL_STATE(1626)] = 60308, + [SMALL_STATE(1627)] = 60315, + [SMALL_STATE(1628)] = 60322, + [SMALL_STATE(1629)] = 60329, + [SMALL_STATE(1630)] = 60336, + [SMALL_STATE(1631)] = 60343, + [SMALL_STATE(1632)] = 60350, + [SMALL_STATE(1633)] = 60357, + [SMALL_STATE(1634)] = 60364, + [SMALL_STATE(1635)] = 60371, + [SMALL_STATE(1636)] = 60378, + [SMALL_STATE(1637)] = 60385, + [SMALL_STATE(1638)] = 60392, + [SMALL_STATE(1639)] = 60399, + [SMALL_STATE(1640)] = 60406, + [SMALL_STATE(1641)] = 60413, + [SMALL_STATE(1642)] = 60420, + [SMALL_STATE(1643)] = 60427, + [SMALL_STATE(1644)] = 60434, + [SMALL_STATE(1645)] = 60441, + [SMALL_STATE(1646)] = 60448, + [SMALL_STATE(1647)] = 60455, + [SMALL_STATE(1648)] = 60462, + [SMALL_STATE(1649)] = 60469, + [SMALL_STATE(1650)] = 60476, + [SMALL_STATE(1651)] = 60483, + [SMALL_STATE(1652)] = 60490, + [SMALL_STATE(1653)] = 60497, + [SMALL_STATE(1654)] = 60504, + [SMALL_STATE(1655)] = 60511, + [SMALL_STATE(1656)] = 60518, + [SMALL_STATE(1657)] = 60525, + [SMALL_STATE(1658)] = 60532, + [SMALL_STATE(1659)] = 60539, + [SMALL_STATE(1660)] = 60546, + [SMALL_STATE(1661)] = 60553, + [SMALL_STATE(1662)] = 60560, + [SMALL_STATE(1663)] = 60567, + [SMALL_STATE(1664)] = 60574, + [SMALL_STATE(1665)] = 60581, + [SMALL_STATE(1666)] = 60588, + [SMALL_STATE(1667)] = 60595, + [SMALL_STATE(1668)] = 60602, + [SMALL_STATE(1669)] = 60609, + [SMALL_STATE(1670)] = 60616, + [SMALL_STATE(1671)] = 60623, + [SMALL_STATE(1672)] = 60630, + [SMALL_STATE(1673)] = 60637, + [SMALL_STATE(1674)] = 60644, + [SMALL_STATE(1675)] = 60651, + [SMALL_STATE(1676)] = 60658, + [SMALL_STATE(1677)] = 60665, + [SMALL_STATE(1678)] = 60672, + [SMALL_STATE(1679)] = 60679, + [SMALL_STATE(1680)] = 60686, + [SMALL_STATE(1681)] = 60693, + [SMALL_STATE(1682)] = 60700, + [SMALL_STATE(1683)] = 60707, + [SMALL_STATE(1684)] = 60714, + [SMALL_STATE(1685)] = 60721, + [SMALL_STATE(1686)] = 60728, + [SMALL_STATE(1687)] = 60735, + [SMALL_STATE(1688)] = 60742, + [SMALL_STATE(1689)] = 60749, + [SMALL_STATE(1690)] = 60756, + [SMALL_STATE(1691)] = 60763, + [SMALL_STATE(1692)] = 60770, + [SMALL_STATE(1693)] = 60777, + [SMALL_STATE(1694)] = 60784, + [SMALL_STATE(1695)] = 60791, + [SMALL_STATE(1696)] = 60798, + [SMALL_STATE(1697)] = 60805, + [SMALL_STATE(1698)] = 60812, + [SMALL_STATE(1699)] = 60819, + [SMALL_STATE(1700)] = 60826, + [SMALL_STATE(1701)] = 60833, + [SMALL_STATE(1702)] = 60840, + [SMALL_STATE(1703)] = 60847, + [SMALL_STATE(1704)] = 60854, + [SMALL_STATE(1705)] = 60861, + [SMALL_STATE(1706)] = 60868, + [SMALL_STATE(1707)] = 60875, + [SMALL_STATE(1708)] = 60882, + [SMALL_STATE(1709)] = 60889, + [SMALL_STATE(1710)] = 60896, + [SMALL_STATE(1711)] = 60903, + [SMALL_STATE(1712)] = 60910, + [SMALL_STATE(1713)] = 60917, + [SMALL_STATE(1714)] = 60924, + [SMALL_STATE(1715)] = 60931, + [SMALL_STATE(1716)] = 60938, + [SMALL_STATE(1717)] = 60945, + [SMALL_STATE(1718)] = 60952, + [SMALL_STATE(1719)] = 60959, + [SMALL_STATE(1720)] = 60966, + [SMALL_STATE(1721)] = 60973, + [SMALL_STATE(1722)] = 60980, + [SMALL_STATE(1723)] = 60987, + [SMALL_STATE(1724)] = 60994, + [SMALL_STATE(1725)] = 61001, + [SMALL_STATE(1726)] = 61008, + [SMALL_STATE(1727)] = 61015, + [SMALL_STATE(1728)] = 61022, + [SMALL_STATE(1729)] = 61029, + [SMALL_STATE(1730)] = 61036, + [SMALL_STATE(1731)] = 61043, + [SMALL_STATE(1732)] = 61050, + [SMALL_STATE(1733)] = 61057, + [SMALL_STATE(1734)] = 61064, + [SMALL_STATE(1735)] = 61071, + [SMALL_STATE(1736)] = 61078, + [SMALL_STATE(1737)] = 61085, + [SMALL_STATE(1738)] = 61092, + [SMALL_STATE(1739)] = 61099, + [SMALL_STATE(1740)] = 61106, + [SMALL_STATE(1741)] = 61113, + [SMALL_STATE(1742)] = 61120, + [SMALL_STATE(1743)] = 61127, + [SMALL_STATE(1744)] = 61134, + [SMALL_STATE(1745)] = 61141, + [SMALL_STATE(1746)] = 61148, + [SMALL_STATE(1747)] = 61155, + [SMALL_STATE(1748)] = 61162, + [SMALL_STATE(1749)] = 61169, + [SMALL_STATE(1750)] = 61176, + [SMALL_STATE(1751)] = 61183, + [SMALL_STATE(1752)] = 61190, + [SMALL_STATE(1753)] = 61197, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -57644,34 +57588,34 @@ static const TSParseActionEntry ts_parse_actions[] = { [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(408), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1062), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1057), [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1268), - [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1384), - [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1367), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1238), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1428), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1268), [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1404), - [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1447), - [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1758), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1573), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1449), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1458), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1656), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1681), [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1227), - [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1204), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1381), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1181), + [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1154), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1408), [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), - [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1452), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1481), - [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1343), - [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1655), - [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1657), - [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1350), - [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1679), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1465), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1538), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1346), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1711), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1721), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1265), + [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1454), [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(526), [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(510), [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(510), @@ -57684,113 +57628,113 @@ static const TSParseActionEntry ts_parse_actions[] = { [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), [87] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), - [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1685), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1678), [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1051), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1045), [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(218), [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), - [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1247), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1215), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1241), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1209), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1707), [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193), [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(194), [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(5), - [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1754), - [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1715), - [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1366), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1642), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1747), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1708), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1361), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1635), [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(393), [131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), [133] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(408), - [136] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1062), + [136] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1057), [139] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(4), - [142] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1268), - [145] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1384), - [148] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1367), + [142] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1238), + [145] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1428), + [148] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1268), [151] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(142), - [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1404), - [157] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1447), - [160] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1018), - [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1758), - [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1573), + [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1449), + [157] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1458), + [160] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1035), + [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1656), + [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1681), [169] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(159), [172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(43), [175] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(187), [178] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(190), - [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1227), - [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1204), - [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1381), + [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1181), + [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1154), + [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1408), [190] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(197), [193] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(59), [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), - [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1452), - [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1481), - [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), - [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1655), - [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1657), - [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1350), - [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1679), + [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1538), + [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1346), + [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1711), + [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1721), + [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1265), + [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1454), [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(526), [223] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(510), [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(510), [229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(227), [232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), [234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), - [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), - [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), - [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), - [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), + [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1667), + [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), + [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), + [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(705), - [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1670), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(228), [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1437), + [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1452), [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1035), + [260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1030), [262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), [268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), - [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1241), - [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1165), - [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1680), + [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1235), + [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1159), + [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1673), [276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(182), [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), - [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1748), - [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1681), - [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1270), - [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1556), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1741), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1674), + [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1264), + [290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1549), [292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), [294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), [296] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), [298] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), [300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), - [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1558), - [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1018), + [302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1551), + [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1035), [306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), [308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), - [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1184), - [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1542), - [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1322), - [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1504), - [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1561), - [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1682), - [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1418), - [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1459), - [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1283), - [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1553), + [310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1140), + [312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1369), + [314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1271), + [316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1582), + [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1447), + [320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1467), + [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1506), + [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1581), + [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1286), + [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1643), [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(405), [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), [338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), @@ -57813,7 +57757,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), [376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(407), [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), - [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), [386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), @@ -57826,20 +57770,20 @@ static const TSParseActionEntry ts_parse_actions[] = { [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), [403] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), [405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), - [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), - [409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1174), - [412] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(835), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), + [409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1168), + [412] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(828), [415] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2, 0, 0), [417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2, 0, 0), [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), [421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), - [423] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1659), + [423] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1654), [426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), [428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), - [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 66), - [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1664), - [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1364), - [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 66), + [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 65), + [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), + [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1359), + [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 65), [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), [440] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), @@ -57850,11 +57794,11 @@ static const TSParseActionEntry ts_parse_actions[] = { [452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), [454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(767), - [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), - [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 127), - [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 127), - [466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1177), + [458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 128), + [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 128), + [466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1171), [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), @@ -57866,32 +57810,32 @@ static const TSParseActionEntry ts_parse_actions[] = { [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 13), [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 13), [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [491] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1364), + [491] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1359), [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_expression, 4, 0, 21), [498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_kernel_expression, 4, 0, 21), [500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), - [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 38), - [506] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1364), - [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), - [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 44), - [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 44), - [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 51), - [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 51), - [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 58), - [521] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1364), - [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), - [526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 64), - [528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 64), + [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 36), + [506] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1359), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 42), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 42), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 52), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 52), + [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 57), + [521] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 57), SHIFT(1359), + [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 57), + [526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 6, 0, 63), + [528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 6, 0, 63), [530] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 84), - [532] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1364), + [532] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1359), [535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), [537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 7, 0, 100), [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 7, 0, 100), - [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 109), - [543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1364), - [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), + [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 110), + [543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 110), SHIFT(1359), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 110), [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), @@ -57920,8 +57864,8 @@ static const TSParseActionEntry ts_parse_actions[] = { [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), [604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), [606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), - [608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 35), - [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 35), + [608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 33), + [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 33), [612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), [614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), [616] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), @@ -57936,24 +57880,24 @@ static const TSParseActionEntry ts_parse_actions[] = { [634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 30), [636] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), [638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), - [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 35), - [642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 35), + [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 33), + [642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 33), [644] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), [646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), [648] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), [651] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), [654] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), [656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), - [658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 70), - [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 70), + [658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 69), + [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 69), [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), [664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), [666] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 99), [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 99), [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), - [674] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 70), - [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 70), + [674] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 69), + [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 69), [678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 101), [680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 101), [682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), @@ -57962,14 +57906,14 @@ static const TSParseActionEntry ts_parse_actions[] = { [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 8, 0, 101), [690] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), [692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), - [694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 143), - [696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 143), - [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), - [700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1223), - [703] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1550), - [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), - [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), - [710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 178), + [694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 144), + [696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 144), + [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), + [700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1217), + [703] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1544), + [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1496), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), + [710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 179), [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), [714] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), @@ -57980,128 +57924,128 @@ static const TSParseActionEntry ts_parse_actions[] = { [726] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), + [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1645), [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 86), - [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 111), - [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 114), + [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 112), + [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 115), [740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 87), - [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 54), - [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 129), - [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 130), - [748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 135), - [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 138), - [752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 139), - [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 57), - [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 149), - [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 152), - [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 156), - [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 157), - [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), - [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 162), - [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 165), - [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 166), - [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 168), - [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), - [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 177), + [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 53), + [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 130), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 131), + [748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 136), + [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 139), + [752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 140), + [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 56), + [756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 150), + [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 153), + [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 157), + [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), + [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 160), + [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 163), + [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 166), + [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 167), + [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 169), + [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 172), + [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 178), [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 18), - [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 180), - [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 181), - [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), - [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 186), - [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 189), - [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 190), - [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 193), - [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 194), - [796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 197), - [798] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1225), - [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 59), - [803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 104), - [805] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1368), - [808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1368), - [811] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1368), - [814] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1368), - [817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1368), - [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 103), - [822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 47), - [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 47), SHIFT(1364), - [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 47), - [829] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 47), - [831] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 47), SHIFT(1364), - [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 47), - [836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), - [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), - [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), - [843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1269), + [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 181), + [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 182), + [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), + [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 187), + [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 190), + [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 191), + [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 194), + [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 195), + [796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 198), + [798] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1219), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 58), + [803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 105), + [805] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1316), + [808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1316), + [811] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 57), SHIFT(1316), + [814] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1316), + [817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 110), SHIFT(1316), + [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 104), + [822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 45), + [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), SHIFT(1359), + [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 45), + [829] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 45), + [831] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), SHIFT(1359), + [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 45), + [836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1542), + [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1542), + [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1481), + [843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1161), [846] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(188), [849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), - [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), - [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(747), + [853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), - [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1724), - [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), - [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1725), - [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), - [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), - [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), - [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), - [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), - [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), - [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), - [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1717), + [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), + [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1670), + [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), + [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), + [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), + [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), + [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), + [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), + [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), [881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), [883] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), - [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1580), - [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1733), - [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), + [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1735), + [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1736), [892] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), - [894] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), + [894] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1545), [897] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1471), - [900] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1724), - [903] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1676), - [906] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1725), - [909] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1677), - [912] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1726), - [915] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1352), - [918] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(594), - [921] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1683), + [900] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1717), + [903] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1669), + [906] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1718), + [909] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1670), + [912] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1719), + [915] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1349), + [918] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(598), + [921] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1676), [924] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), - [927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1750), - [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), - [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), - [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1752), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1498), + [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), [937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(725), [939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), - [941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1427), + [941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), [943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), - [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), - [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), - [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(708), [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), - [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), - [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), - [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), - [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), - [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), + [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1470), + [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1513), + [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1389), [977] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), [979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), - [981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), - [983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), - [985] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(827), + [983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [985] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1481), [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), [990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1651), [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), - [998] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 58), SHIFT(1342), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1625), + [998] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 57), SHIFT(1344), [1001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), [1003] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), @@ -58111,1159 +58055,1158 @@ static const TSParseActionEntry ts_parse_actions[] = { [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), [1015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [1019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), + [1019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), [1023] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), - [1025] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1149), - [1028] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1342), - [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 65), - [1033] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 43), + [1025] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1125), + [1028] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), SHIFT(1344), + [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 64), + [1033] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 41), [1035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), - [1037] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 38), SHIFT(1342), - [1040] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1342), + [1037] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 36), SHIFT(1344), + [1040] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 84), SHIFT(1344), [1043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), - [1045] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 109), SHIFT(1342), + [1045] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 110), SHIFT(1344), [1048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), [1050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), [1052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), [1054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [1058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(831), - [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [1058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), + [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), - [1066] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1076), - [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), - [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), - [1072] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1117), - [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), - [1076] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 45), + [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [1066] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1072), + [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), + [1072] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1067), + [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), + [1076] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 4, 0, 43), [1078] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 17), - [1080] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 67), - [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [1080] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_kernel_arm, 5, 0, 66), + [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1746), [1084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), - [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(754), + [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [1094] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), - [1097] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1271), - [1100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [1102] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1276), - [1105] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), - [1108] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(628), - [1111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1279), - [1114] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1117), - [1117] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), - [1120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), - [1122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), - [1124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [1126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), - [1128] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), - [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), - [1132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), - [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), - [1136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), - [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), - [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), - [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), - [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), - [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), - [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), - [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1589), - [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), - [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), - [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), - [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), - [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), - [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), - [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), - [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), - [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), - [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), - [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), - [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), - [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), - [1196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), - [1198] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(829), - [1201] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1271), - [1204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), - [1206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1276), - [1209] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), - [1212] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(628), - [1215] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1279), - [1218] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1117), - [1221] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1076), - [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), - [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), - [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1671), - [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), - [1236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), - [1238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), - [1240] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), - [1242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), - [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), - [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), - [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), - [1252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), - [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), - [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(508), - [1258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), - [1260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), - [1262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), - [1264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), - [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(833), - [1268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [1270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), - [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1586), - [1276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), - [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1669), - [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), - [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), - [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1493), - [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1499), - [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1318), - [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), - [1292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(691), - [1294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), - [1296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(696), - [1298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(704), - [1300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), - [1302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), - [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), - [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1489), - [1309] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1493), - [1312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1499), - [1315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1725), - [1318] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1677), - [1321] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1318), - [1324] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1508), - [1327] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), - [1330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), - [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), - [1334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), - [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), - [1338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), - [1340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1126), - [1343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), - [1345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), - [1347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), - [1349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), - [1351] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1544), - [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 55), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), - [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 90), - [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 19), - [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 133), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1609), + [1096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), + [1098] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(826), + [1101] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), + [1104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [1106] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1277), + [1109] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1072), + [1112] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(630), + [1115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1280), + [1118] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1067), + [1121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1072), + [1124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 20), + [1126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), + [1128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [1132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(826), + [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [1136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), + [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), + [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), + [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [1198] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), + [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1054), + [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [1206] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(826), + [1209] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), + [1212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), + [1214] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1277), + [1217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1072), + [1220] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(630), + [1223] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1280), + [1226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1067), + [1229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1072), + [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1664), + [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), + [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), + [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), + [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), + [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), + [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(508), + [1254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), + [1256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), + [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), + [1260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), + [1262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), + [1264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), + [1266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), + [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), + [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), + [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1672), + [1276] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1495), + [1279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), + [1281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [1285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1493), + [1287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1499), + [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1502), + [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1317), + [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1516), + [1295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [1297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), + [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(691), + [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), + [1303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), + [1305] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1493), + [1308] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1499), + [1311] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1502), + [1314] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1718), + [1317] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1670), + [1320] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1317), + [1323] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1516), + [1326] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [1329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(704), + [1331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), + [1333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(696), + [1335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [1337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), + [1339] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1253), + [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), + [1344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1253), + [1346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), + [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), + [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 54), + [1354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), + [1356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 19), + [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 134), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 90), + [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 91), [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 22), - [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), - [1370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), - [1372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(623), - [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), - [1376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1720), - [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), - [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 41), - [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), - [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 42), - [1386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 41), - [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 62), - [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), - [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), - [1394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(922), - [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), - [1398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1697), - [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(818), - [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 42), - [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 79), - [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), - [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 80), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 41), - [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 98), - [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 107), - [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), - [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 80), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 116), - [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 98), - [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 134), - [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 116), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 154), - [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 134), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 154), - [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 187), - [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 55), + [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 22), + [1370] = {.entry = {.count = 1, .reusable = false}}, SHIFT(613), + [1372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), + [1374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1713), + [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), + [1378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 39), + [1380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [1382] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 40), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 39), + [1386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(848), + [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), + [1390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1690), + [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), + [1394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 61), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), + [1398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 40), + [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 79), + [1404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(891), + [1406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 80), + [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 39), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 98), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 108), + [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), + [1416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 80), + [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 117), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 98), + [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 135), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 117), + [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 155), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 135), + [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 10, 0, 155), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), + [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 189), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 54), [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), - [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 40), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 38), [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 81), - [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 56), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 55), [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 82), - [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 36), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 34), [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 85), [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 88), [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 89), - [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 56), - [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 71), - [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 105), - [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 106), - [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 36), + [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 55), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 70), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 106), + [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 107), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 34), [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), - [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), - [1470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), - [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), - [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 81), - [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 108), - [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 82), - [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 110), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), + [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), + [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 81), + [1474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 109), + [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 82), + [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 71), + [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 111), [1482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 72), - [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 112), - [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 113), - [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 73), - [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 115), - [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 91), - [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 60), - [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 61), - [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 128), - [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 131), - [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 132), - [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), - [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 108), - [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 136), - [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 50), - [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 140), - [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), - [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 148), - [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 150), - [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 151), - [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 153), - [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 133), + [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 113), + [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 114), + [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 116), + [1490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 91), + [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 59), + [1494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 129), + [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 132), + [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 133), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 60), + [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 109), + [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 137), + [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 48), + [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 141), + [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 19), + [1514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 149), + [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 151), + [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 152), + [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 154), + [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 134), + [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), - [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 155), - [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 158), - [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 163), - [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 164), - [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 167), - [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 48), - [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 169), - [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 170), - [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 176), - [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 179), - [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 183), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 156), + [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 159), + [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 164), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 165), + [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 168), + [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 46), + [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 170), + [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 171), + [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 177), + [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 180), + [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 184), + [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 188), [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), - [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 188), - [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 195), - [1558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 102), - [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 48), - [1562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), - [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 71), - [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 50), - [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 78), - [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 49), - [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 137), - [1574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1562), - [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), - [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(983), - [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(961), - [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), - [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), - [1586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), - [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), - [1592] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1500), - [1595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1559), - [1597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1507), - [1599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), - [1601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1380), - [1603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), - [1605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(931), - [1607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), - [1609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 125), - [1611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), - [1613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), - [1615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), - [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), - [1619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), - [1621] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1551), - [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1449), - [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), - [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1638), - [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), - [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), - [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), - [1636] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 98), - [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), - [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), - [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), - [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), - [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), - [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), - [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), - [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 173), - [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), - [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), - [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), - [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), - [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(680), - [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), - [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), - [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1613), - [1672] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1562), - [1675] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), - [1677] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(983), - [1680] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(961), - [1683] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), - [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), - [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), - [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), - [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 192), - [1696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 161), - [1698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 76), - [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), - [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), - [1704] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 145), - [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1536), - [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1576), - [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1400), - [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1730), - [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1577), - [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1731), - [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), - [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), - [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), - [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(559), - [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), - [1728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), - [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), - [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), - [1734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 184), - [1736] = {.entry = {.count = 1, .reusable = false}}, SHIFT(871), - [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1389), - [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), - [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1524), - [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), - [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), - [1748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 147), - [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), - [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), - [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), - [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), - [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), - [1760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(834), - [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [1764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), - [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), - [1768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 98), - [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), - [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), - [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), - [1776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 185), - [1778] = {.entry = {.count = 1, .reusable = false}}, SHIFT(984), - [1780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(437), - [1782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), - [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 124), - [1786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 126), - [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), - [1790] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1547), - [1793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 146), - [1795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 74), - [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), - [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 160), - [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 91), - [1803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), - [1805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), - [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 172), - [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), - [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 174), - [1813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 175), - [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 191), - [1817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 75), - [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 196), - [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 97), - [1823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), - [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1148), - [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), - [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), - [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), - [1833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), - [1835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 97), - [1837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 97), - [1839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), - [1843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 121), - [1845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 121), - [1847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 142), - [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 142), - [1851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 141), - [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 141), - [1855] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1634), - [1857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), - [1859] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1632), - [1861] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1643), - [1863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), - [1865] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1640), - [1867] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1648), - [1869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(957), - [1871] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 63), - [1873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 63), - [1875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), - [1877] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 92), - [1879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 92), - [1881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1698), - [1883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), - [1885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1695), - [1887] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 93), - [1889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 93), - [1891] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 94), - [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 94), - [1895] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 122), - [1897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 122), - [1899] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1502), - [1901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), - [1903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1473), - [1905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 117), - [1907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 117), - [1909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 118), - [1911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 118), - [1913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 95), - [1915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 95), - [1917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 96), - [1919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 96), - [1921] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1512), - [1923] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), - [1925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 119), - [1927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 119), - [1929] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 120), - [1931] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 120), - [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [1937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), - [1939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1102), - [1941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [1943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), - [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [1947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), - [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [1953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), - [1955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [1957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), - [1959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), - [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), - [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), - [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), - [1975] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), - [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [1981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), - [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), - [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), - [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), - [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), - [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), - [2003] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1545), - [2005] = {.entry = {.count = 1, .reusable = false}}, SHIFT(950), - [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), - [2011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1362), - [2013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1739), - [2015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1094), - [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), - [2019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1090), - [2021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), - [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), - [2027] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [2029] = {.entry = {.count = 1, .reusable = false}}, SHIFT(121), - [2031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), - [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [2035] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), - [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), - [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), - [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), - [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), - [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [2067] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), - [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), - [2071] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), - [2073] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), - [2075] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), - [2077] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), - [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1630), - [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), - [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1645), - [2085] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), - [2087] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), - [2089] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), - [2091] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), - [2093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), - [2095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), - [2097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), - [2099] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1090), - [2102] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), - [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), - [2106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [2108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1496), - [2110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), - [2112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [2114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [2116] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), - [2118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), - [2120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), - [2122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1180), - [2124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), - [2126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), - [2128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1153), - [2130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), - [2132] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1570), - [2135] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), - [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), - [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), - [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), - [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 123), - [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 144), - [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), - [2149] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1741), - [2152] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), - [2154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [2156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1675), - [2158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), - [2160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 68), - [2162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(706), - [2164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), - [2166] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), - [2168] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(196), - [2171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1570), - [2173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), - [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1175), - [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [2179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), - [2181] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), - [2183] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1162), - [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), - [2188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1162), - [2190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), - [2192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), - [2194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), - [2196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), - [2198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), - [2200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), - [2202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1741), - [2205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), - [2207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), - [2209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), - [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), - [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), - [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), - [2217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 46), - [2219] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), - [2221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), - [2223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), - [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), - [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), - [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), - [2231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), - [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(782), - [2235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(856), - [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), - [2240] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1741), - [2243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), - [2245] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1153), - [2248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), - [2250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 68), - [2252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), - [2254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), - [2256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), - [2258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [2260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [2262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), - [2264] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1580), - [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), - [2269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), - [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), - [2273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), - [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), - [2277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [2279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), - [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), - [2283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), - [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [2287] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 69), SHIFT_REPEAT(633), - [2290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 69), - [2292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), - [2294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), - [2296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), - [2298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), - [2300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), - [2302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), - [2304] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1338), - [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), - [2313] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), - [2315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), - [2317] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1300), - [2320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [2322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [2324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), - [2326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), - [2328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), - [2330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 34), - [2332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), - [2334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [2336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(945), - [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), - [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), - [2342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [2346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), - [2348] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(35), - [2351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [2353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), - [2355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1289), - [2357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), - [2359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 3, 0, 52), - [2361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), - [2363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), - [2365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), - [2367] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), - [2369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), - [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [2373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), - [2375] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1321), - [2378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [2380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), - [2382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), - [2384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [2386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), - [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), - [2390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [2392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [2394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [2396] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 53), SHIFT_REPEAT(816), - [2399] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 53), - [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), - [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), - [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), - [2407] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), - [2409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1580), - [2412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), - [2414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [2416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [2418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), - [2420] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1311), - [2423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), - [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), - [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), - [2431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), - [2433] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 69), SHIFT_REPEAT(1291), - [2436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 69), - [2438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [2440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [2442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), - [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), - [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), - [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [2450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), - [2452] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1213), - [2455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), - [2457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), - [2459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), - [2461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [2463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(503), - [2465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [2467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 1, 0, 0), - [2469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [2471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [2473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), - [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [2477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(969), - [2479] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1357), - [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [2483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [2485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), - [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), - [2489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [2491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [2493] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1335), - [2496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), - [2498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [2500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), - [2502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), - [2504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), - [2506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), - [2508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(953), - [2510] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1354), - [2512] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(634), - [2515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), - [2517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), - [2519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), - [2521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), - [2523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), - [2525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(965), - [2527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1360), - [2529] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1645), - [2532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), - [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [2536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), - [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), - [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 33), - [2552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [2556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), - [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [2560] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1135), - [2563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), - [2565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [2569] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1097), - [2572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), - [2574] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1580), - [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), - [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), - [2581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), - [2583] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 3, 0, 77), - [2585] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1299), - [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), - [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), - [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [2593] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1073), - [2595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 83), - [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), - [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), - [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), - [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1109), - [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1609), - [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), - [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [2613] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1349), - [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), - [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), - [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), - [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), - [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), - [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), - [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), - [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), - [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(994), - [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), - [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1055), - [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), - [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), - [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1371), - [2651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 0), - [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), - [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), - [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), - [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), - [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), - [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), - [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), - [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), - [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), - [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), - [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1000), - [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), - [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), - [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), - [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 196), + [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 102), + [1558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 46), + [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), + [1562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 70), + [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 48), + [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 78), + [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 47), + [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 138), + [1572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1571), + [1574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [1576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(974), + [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(962), + [1580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), + [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1526), + [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), + [1588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 22), + [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), + [1592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [1594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), + [1596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1548), + [1598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 126), + [1600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), + [1602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1591), + [1604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), + [1606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), + [1608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), + [1610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), + [1612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), + [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), + [1616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [1618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), + [1622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 98), + [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), + [1634] = {.entry = {.count = 1, .reusable = false}}, SHIFT(651), + [1636] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1390), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), + [1640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(858), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 174), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), + [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(680), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), + [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), + [1666] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1571), + [1669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), + [1671] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(974), + [1674] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(962), + [1677] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(227), + [1680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), + [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [1686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), + [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 146), + [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), + [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), + [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1724), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1725), + [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), + [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(561), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), + [1710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(845), + [1712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 75), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [1720] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 185), + [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 193), + [1724] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 162), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1384), + [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1527), + [1734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 22), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), + [1740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 98), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), + [1744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 148), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [1748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 28), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [1756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), + [1758] = {.entry = {.count = 1, .reusable = false}}, SHIFT(833), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), + [1762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), + [1766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), + [1768] = {.entry = {.count = 1, .reusable = false}}, SHIFT(437), + [1770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), + [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 125), + [1774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 127), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), + [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), + [1786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(983), + [1788] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1539), + [1791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 147), + [1793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 73), + [1795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 161), + [1797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 91), + [1799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), + [1801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), + [1803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 173), + [1805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), + [1807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 175), + [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 176), + [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 74), + [1813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 186), + [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 192), + [1817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 197), + [1819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 97), + [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 19), + [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), + [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), + [1827] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 96), + [1829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 96), + [1831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 142), + [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 142), + [1835] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1515), + [1837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), + [1839] = {.entry = {.count = 1, .reusable = false}}, SHIFT(942), + [1841] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 6, 0, 143), + [1843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 6, 0, 143), + [1845] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1632), + [1847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), + [1849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1631), + [1851] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1639), + [1853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), + [1855] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1638), + [1857] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1646), + [1859] = {.entry = {.count = 1, .reusable = false}}, SHIFT(952), + [1861] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 97), + [1863] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 97), + [1865] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 123), + [1867] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 123), + [1869] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1871] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 20), + [1873] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 118), + [1875] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 118), + [1877] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 119), + [1879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 119), + [1881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1745), + [1883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), + [1885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1744), + [1887] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 120), + [1889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 120), + [1891] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 92), + [1895] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 121), + [1897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 121), + [1899] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 93), + [1901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 93), + [1903] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 94), + [1905] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 94), + [1907] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 5, 0, 122), + [1909] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 5, 0, 122), + [1911] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1482), + [1913] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1472), + [1915] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 3, 0, 62), + [1917] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 62), + [1919] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operation_declaration, 4, 0, 95), + [1921] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 4, 0, 95), + [1923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [1925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [1927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), + [1929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1100), + [1931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [1937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [1939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [1941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), + [1945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [1949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [1953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [1955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), + [1957] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1959] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicity, 1, 0, 0), + [1961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), + [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), + [1969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), + [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [1975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), + [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), + [1981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), + [1989] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1535), + [1991] = {.entry = {.count = 1, .reusable = false}}, SHIFT(943), + [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), + [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), + [2001] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1360), + [2003] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1738), + [2005] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1070), + [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1314), + [2009] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1082), + [2011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [2013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [2019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), + [2021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(121), + [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [2027] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), + [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1657), + [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), + [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), + [2055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), + [2057] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [2059] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), + [2061] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [2063] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [2067] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2069] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1586), + [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), + [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), + [2077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1606), + [2079] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2081] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(971), + [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), + [2089] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1082), + [2092] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), + [2094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [2096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), + [2098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1363), + [2100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [2102] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), + [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [2106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), + [2108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), + [2110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), + [2112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1712), + [2114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [2116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 20), + [2118] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), SHIFT_REPEAT(851), + [2121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_positional_payload_repeat1, 2, 0, 0), + [2123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1373), + [2125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), + [2129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), + [2131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [2133] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(196), + [2136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), + [2138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [2140] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [2142] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1381), + [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), + [2147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_pattern, 4, 0, 67), + [2149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 145), + [2151] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1138), + [2154] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 124), + [2156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1675), + [2158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110), + [2160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), + [2162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [2164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [2166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), + [2168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), + [2170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), + [2172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), + [2174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1289), + [2176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1366), + [2178] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), + [2180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(706), + [2182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), + [2184] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 3, 0, 0), + [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), + [2188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 44), + [2190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), + [2192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(779), + [2194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [2196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), + [2198] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_structural_pattern, 5, 0, 0), + [2200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [2202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1706), + [2204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), + [2206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), SHIFT_REPEAT(1381), + [2209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [2211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [2215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), + [2217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), + [2219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), + [2221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(765), + [2223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1675), + [2226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_kernel_expression_repeat1, 2, 0, 0), + [2228] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1381), + [2231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), + [2233] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1191), + [2236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), + [2242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 67), + [2244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), + [2246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), + [2248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [2250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), + [2252] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), + [2254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), + [2256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), + [2258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), + [2260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 1, 0, 0), + [2262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), + [2264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [2266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), + [2268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [2270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [2272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), + [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [2276] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 68), SHIFT_REPEAT(635), + [2279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 68), + [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [2283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), + [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), + [2287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), + [2289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [2291] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), + [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), + [2295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), + [2297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [2299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1507), + [2301] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), + [2303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), + [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), + [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), + [2309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), + [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [2313] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 2, 0, 0), + [2315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), + [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1319), + [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), + [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [2323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [2327] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(632), + [2330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), + [2332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [2334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1675), + [2336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), + [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [2342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [2344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), + [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), + [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), + [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2356] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1166), + [2359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), + [2361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [2363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(503), + [2365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), + [2367] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1605), + [2370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), + [2372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), + [2374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [2376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [2378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [2380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [2382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(963), + [2384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1267), + [2386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), + [2388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [2390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), + [2392] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1311), + [2395] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1166), + [2399] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), + [2401] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1080), + [2404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), + [2406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [2410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), + [2412] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1319), + [2415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [2417] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1142), + [2420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), + [2422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 20), + [2424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 3, 0, 76), + [2428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), + [2430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [2432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1633), + [2434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [2438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), + [2440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [2442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [2450] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 68), SHIFT_REPEAT(1288), + [2453] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 68), + [2455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), + [2457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [2461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), + [2463] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1685), + [2466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [2468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [2470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [2472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1114), + [2474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [2476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), + [2478] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1337), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [2483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [2485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 20), + [2487] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), SHIFT(1605), + [2490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), + [2494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), + [2496] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 77), SHIFT_REPEAT(805), + [2499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 77), + [2501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 15), + [2503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(946), + [2505] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1351), + [2507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [2509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [2511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2513] = {.entry = {.count = 1, .reusable = false}}, SHIFT(958), + [2515] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1357), + [2517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [2519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [2521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), + [2523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 50), + [2525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [2529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [2531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [2533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_payload, 1, 0, 0), + [2535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), + [2537] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1307), + [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), + [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_list, 2, 0, 49), + [2552] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), SHIFT(1605), + [2555] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), + [2557] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(35), + [2560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), + [2562] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1335), + [2565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), + [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), + [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [2571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [2573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), + [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), + [2581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 2, 0, 0), + [2583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), + [2585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), + [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(797), + [2589] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1297), + [2591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 83), + [2593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), + [2595] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), + [2597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 20), + [2599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(908), + [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [2607] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1347), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), + [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), + [2613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(914), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), + [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), + [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), + [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), + [2631] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_type_list_repeat1, 3, 0, 103), + [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), + [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1108), + [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), + [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), + [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), + [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), + [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), + [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), + [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), + [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), + [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(994), + [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), + [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), + [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(774), + [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(997), + [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), + [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1004), + [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), - [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), - [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), - [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), - [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), - [2701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), - [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), - [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(783), - [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), - [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), - [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), - [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), - [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), - [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1005), - [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), - [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), - [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(773), - [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1070), - [2727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 46), - [2729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 46), - [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), - [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), - [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), - [2737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), - [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), - [2741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), - [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), - [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), - [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [2749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), - [2751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 39), - [2753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), - [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), - [2757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), - [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), - [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), - [2765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), - [2769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), - [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), - [2775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(521), - [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), - [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1477), - [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), - [2785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), - [2787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), - [2789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), + [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(780), + [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(782), + [2701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), + [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), + [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), + [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), + [2713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_pattern_repeat1, 2, 0, 44), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(762), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), + [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), + [2725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 44), + [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), + [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), + [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [2737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), + [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [2741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 37), + [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), + [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [2749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), + [2751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [2753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1325), + [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [2757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), + [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [2765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), + [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), + [2769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), + [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [2775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), + [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), + [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [2785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [2787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(521), + [2789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), + [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), [2793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [2795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [2797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), - [2799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [2801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), - [2803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), - [2805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), - [2807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), - [2809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), - [2811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), - [2813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), - [2815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), - [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), - [2819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), - [2821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), - [2823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), - [2825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), - [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [2795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1480), + [2797] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [2799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(768), + [2801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [2803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [2807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), + [2809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), + [2811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(820), + [2813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), + [2815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [2819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), + [2821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), + [2823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), + [2825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), [2829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [2831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1332), - [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), - [2835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), - [2837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), - [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), - [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), - [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), - [2847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), - [2849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [2851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(859), - [2853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), - [2855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), - [2857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), - [2859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), - [2861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), - [2863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), - [2865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(809), - [2867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), - [2869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), - [2871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1598), - [2873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [2875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), - [2877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), - [2879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), - [2881] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [2831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1751), + [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), + [2835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), + [2837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), + [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), + [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(806), + [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), + [2847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), + [2849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [2851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [2853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(769), + [2855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), + [2857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [2859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [2861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [2863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [2865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1556), + [2867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), + [2869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [2871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(801), + [2873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), + [2875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), + [2877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [2879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [2881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1477), [2883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1333), - [2885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [2887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1614), - [2889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1385), - [2891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), - [2893] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), - [2895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), - [2897] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), - [2899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [2901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), - [2903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), - [2905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [2907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), - [2909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), - [2911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), - [2913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), - [2915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), - [2917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [2919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), - [2921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), - [2923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), - [2925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), - [2927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), - [2929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), - [2931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), - [2933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), - [2935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), - [2937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), + [2885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1612), + [2887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1620), + [2889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1322), + [2891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [2893] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1382), + [2895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [2897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_arguments, 4, 0, 51), + [2899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1558), + [2901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [2903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [2905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), + [2907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [2909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [2911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [2913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1583), + [2915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), + [2917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), + [2919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), + [2921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1094), + [2923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), + [2925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), + [2927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1399), + [2929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), + [2931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), + [2933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), + [2935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [2937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), [2939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [2941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), - [2943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(806), - [2945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), - [2947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), - [2949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1546), - [2951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), - [2953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), - [2955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), - [2957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), - [2959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), - [2961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), - [2963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), - [2965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), - [2967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), - [2969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [2971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), - [2973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), - [2975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), - [2977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), - [2979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), - [2981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [2983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [2985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), - [2987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), - [2989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(621), - [2991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [2993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), - [2995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), - [2997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), - [2999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), - [3001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), - [3003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), - [3005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), - [3007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), - [3009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1653), - [3011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(940), - [3013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), - [3015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), - [3017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), - [3019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), - [3021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), - [3023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), - [3025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), - [3027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), - [3029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [3031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1689), - [3033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), - [3035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), - [3037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(772), - [3039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1612), - [3041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), - [3043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(640), - [3045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1118), - [3047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [3049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), - [3051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [3053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [2941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), + [2943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1416), + [2945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), + [2947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [2949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), + [2951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), + [2953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), + [2955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), + [2957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), + [2959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [2961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), + [2963] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), + [2965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [2967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), + [2969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [2971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [2973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1566), + [2975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), + [2977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), + [2979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [2981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [2983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [2985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [2987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), + [2989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(624), + [2991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), + [2993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [2995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), + [2997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [2999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [3001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), + [3003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), + [3005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [3007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [3009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [3011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), + [3013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [3015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [3017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1285), + [3019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [3021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [3023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [3025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1653), + [3027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), + [3029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), + [3031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1345), + [3033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), + [3035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(773), + [3037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), + [3039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [3041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [3043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), + [3045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [3047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [3049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), + [3051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), + [3053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), [3055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), - [3057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), - [3059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1295), - [3061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1312), - [3063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), - [3065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), - [3067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), - [3069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), - [3071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), - [3073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), - [3075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), - [3077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), - [3079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), - [3081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1170), - [3083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), - [3085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1172), - [3087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [3089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [3091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), - [3093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [3095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), - [3097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), - [3099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), - [3101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), - [3103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), - [3105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), - [3107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), - [3109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(780), - [3111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(788), - [3113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), - [3115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [3117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), - [3119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), - [3121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), - [3123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), - [3125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), - [3127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_type_arguments, 3, 0, 34), - [3129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), - [3131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), - [3133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), - [3135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(793), - [3137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), - [3139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [3141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), - [3143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), - [3145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), - [3147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), - [3149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 36), - [3151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 37), - [3153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), - [3155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [3157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), - [3159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1506), - [3161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), - [3163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), - [3165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), - [3167] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [3169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [3171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), - [3173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [3175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [3177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), - [3179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), - [3181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [3183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), - [3185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), - [3187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), - [3189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), - [3191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [3193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [3195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), - [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), - [3201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [3203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), - [3205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), - [3207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), - [3209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), - [3211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), - [3213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), - [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), - [3217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), - [3221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), - [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), - [3225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), - [3227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), - [3229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), - [3231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), - [3233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1185), - [3235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), - [3237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), - [3239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), - [3241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), - [3243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [3245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1599), - [3247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(820), - [3249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [3251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1607), - [3253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1341), - [3255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), - [3257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), - [3259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1617), - [3261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [3263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [3057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [3059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [3061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(638), + [3063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1740), + [3065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1332), + [3067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1555), + [3069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [3071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), + [3073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(968), + [3077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1400), + [3079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [3081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [3083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), + [3085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [3087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), + [3089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [3091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [3093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [3095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [3097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1312), + [3099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [3101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), + [3103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1165), + [3105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), + [3109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [3111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(966), + [3113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), + [3115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), + [3117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), + [3119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), + [3121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(788), + [3123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(761), + [3125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), + [3127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), + [3129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 14), + [3131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1629), + [3133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [3135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(792), + [3137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), + [3139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), + [3141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(893), + [3143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), + [3145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 34), + [3147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [3149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 35), + [3151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), + [3153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), + [3155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), + [3157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(784), + [3159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [3161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [3163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), + [3165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [3167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), + [3169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [3171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1561), + [3173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), + [3175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [3177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [3179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [3181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1460), + [3183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), + [3187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [3189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), + [3191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), + [3193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [3195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [3197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), + [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), + [3201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), + [3203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), + [3205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1376), + [3207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [3209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [3211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), + [3213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), + [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [3217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1574), + [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), + [3221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), + [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [3225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1179), + [3227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), + [3229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), + [3231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), + [3233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), + [3235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), + [3237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), + [3239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [3241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), + [3243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1600), + [3245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), + [3247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), + [3249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1608), + [3251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1610), + [3253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [3255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [3257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), + [3259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1619), + [3261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1621), + [3263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), [3265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1626), - [3267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1628), - [3269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), - [3271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1633), - [3273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), - [3275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), - [3277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [3279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1230), - [3281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [3283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1665), - [3285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), - [3287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), - [3289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1672), - [3291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [3293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), - [3295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), - [3297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), - [3299] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), - [3301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [3303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [3305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1699), - [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), - [3309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1359), - [3311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1704), - [3313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), - [3315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1707), - [3317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1363), - [3319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), - [3321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), - [3323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1752), - [3325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [3327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1722), - [3329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), - [3331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [3333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), - [3337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [3339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), - [3341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), - [3343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), - [3345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), - [3347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), - [3349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [3267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), + [3269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), + [3271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [3273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1224), + [3275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [3277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [3279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), + [3281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1665), + [3283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1679), + [3287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1680), + [3289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), + [3291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), + [3293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), + [3295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), + [3297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), + [3299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), + [3301] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), + [3303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), + [3305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1697), + [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1698), + [3309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), + [3311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [3313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1703), + [3315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [3317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1362), + [3319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [3321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [3323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [3325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), + [3327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), + [3329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [3331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [3333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [3337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), }; enum ts_external_scanner_symbol_identifiers { ts_external_token__call_open_gap = 0, ts_external_token__statement_break = 1, + ts_external_token__type_application_ahead = 2, }; static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { [ts_external_token__call_open_gap] = sym__call_open_gap, [ts_external_token__statement_break] = sym__statement_break, + [ts_external_token__type_application_ahead] = sym__type_application_ahead, }; static const bool ts_external_scanner_states[4][EXTERNAL_TOKEN_COUNT] = { [1] = { [ts_external_token__call_open_gap] = true, [ts_external_token__statement_break] = true, + [ts_external_token__type_application_ahead] = true, }, [2] = { [ts_external_token__call_open_gap] = true, + [ts_external_token__type_application_ahead] = true, }, [3] = { [ts_external_token__statement_break] = true, diff --git a/tree-sitter-osprey/src/scanner.c b/tree-sitter-osprey/src/scanner.c index 292d9363..3addc1ce 100644 --- a/tree-sitter-osprey/src/scanner.c +++ b/tree-sitter-osprey/src/scanner.c @@ -42,6 +42,7 @@ enum TokenType { CALL_OPEN_GAP, STATEMENT_BREAK, + TYPE_APPLICATION_AHEAD, }; void *tree_sitter_osprey_external_scanner_create(void) { return NULL; } @@ -87,6 +88,47 @@ static bool scan_call_open_gap(TSLexer *lexer) { return lexer->lookahead == '('; } +// A glued angle run belongs to a call only when its complete type-shaped +// contents close immediately before '('. A failed lookahead leaves '<' to +// the ordinary comparison/constructor grammar. [TYPE-GENERICS-APPLY] +static bool scan_type_application(TSLexer *lexer) { + lexer->result_symbol = TYPE_APPLICATION_AHEAD; + lexer->mark_end(lexer); + unsigned angles = 0; + bool saw_type = false; + bool word = false; + while (!lexer->eof(lexer)) { + int32_t ch = lexer->lookahead; + if (ch == '<') { + angles++; + word = false; + } else if (ch == '>') { + if (--angles == 0) { + lexer->advance(lexer, false); + return saw_type && lexer->lookahead == '('; + } + word = false; + } else if (ch == '-') { + lexer->advance(lexer, false); + if (lexer->lookahead != '>') return false; + word = false; + } else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_') { + saw_type = true; + word = true; + } else if (ch >= '0' && ch <= '9') { + if (!word) return false; + } else if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || + ch == ',' || ch == ':' || ch == '(' || ch == ')' || + ch == '[' || ch == ']' || ch == '|') { + word = false; + } else { + return false; + } + lexer->advance(lexer, false); + } + return false; +} + // Consumes a `//`-to-end-of-line comment. Returns false on a lone `/`, which // is division and therefore not a line ending. static bool skip_line_comment(TSLexer *lexer) { @@ -162,6 +204,9 @@ static bool scan_statement_break(TSLexer *lexer) { bool tree_sitter_osprey_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) { (void)payload; + if (valid_symbols[TYPE_APPLICATION_AHEAD] && lexer->lookahead == '<') { + return scan_type_application(lexer); + } if (valid_symbols[CALL_OPEN_GAP] && scan_call_open_gap(lexer)) { return true; } From 92c68e6ad5be198c9ad5f062b354f5f2d3ce97e7 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Thu, 10 Sep 2026 07:27:12 +1000 Subject: [PATCH 09/10] fixes --- crates/osprey-codegen/src/aggregate.rs | 17 +- crates/osprey-codegen/src/builder.rs | 10 +- crates/osprey-codegen/src/cast.rs | 10 +- crates/osprey-codegen/src/closure.rs | 58 +- crates/osprey-codegen/src/curry.rs | 23 +- crates/osprey-codegen/src/effects.rs | 1 + crates/osprey-codegen/src/expr.rs | 180 ++++- crates/osprey-codegen/src/extern_call.rs | 33 +- crates/osprey-codegen/src/fiber.rs | 3 + crates/osprey-codegen/src/genfn.rs | 10 +- crates/osprey-codegen/src/gpu_kernel.rs | 2 + crates/osprey-codegen/src/lower.rs | 7 +- crates/osprey-codegen/src/monofn.rs | 4 + crates/osprey-codegen/src/stmt.rs | 9 +- crates/osprey-codegen/src/types.rs | 19 +- crates/osprey-lsp/src/analysis.rs | 5 +- crates/osprey-lsp/src/diagnostics.rs | 45 +- crates/osprey-project/src/rewrite.rs | 3 + crates/osprey-syntax/src/default/expr.rs | 27 +- crates/osprey-syntax/src/ml/lower.rs | 144 +++- crates/osprey-syntax/src/ml/module_lower.rs | 4 +- crates/osprey-types/src/applications.rs | 49 +- crates/osprey-types/src/check.rs | 202 ++++-- crates/osprey-types/src/effect_rows.rs | 678 ++++++++++++++++-- crates/osprey-types/src/env.rs | 4 +- crates/osprey-types/src/expr.rs | 351 ++++++--- crates/osprey-types/src/fields.rs | 77 ++ .../osprey-types/src/generics_apply_tests.rs | 6 +- .../src/generics_variance_assign_tests.rs | 6 +- .../src/generics_variance_shape_tests.rs | 19 +- .../src/generics_variance_tests.rs | 64 +- crates/osprey-types/src/info.rs | 9 +- crates/osprey-types/src/lib.rs | 6 +- crates/osprey-types/src/methods.rs | 286 ++++++++ crates/osprey-types/src/redundant.rs | 127 +++- crates/osprey-types/src/redundant_sites.rs | 134 +++- crates/osprey-types/src/redundant_tests.rs | 153 +++- docs/plans/0015-generics-and-variance.md | 353 +++++++-- docs/specs/0004-TypeSystem.md | 93 ++- docs/specs/0005-FunctionCalls.md | 11 +- .../0011-LightweightFibersAndConcurrency.md | 18 +- docs/specs/0012-Built-InFunctions.md | 23 + docs/specs/0017-AlgebraicEffects.md | 24 + docs/specs/0023-LanguageFlavors.md | 12 + 44 files changed, 2820 insertions(+), 499 deletions(-) create mode 100644 crates/osprey-types/src/fields.rs create mode 100644 crates/osprey-types/src/methods.rs diff --git a/crates/osprey-codegen/src/aggregate.rs b/crates/osprey-codegen/src/aggregate.rs index 0734d412..d5defe76 100644 --- a/crates/osprey-codegen/src/aggregate.rs +++ b/crates/osprey-codegen/src/aggregate.rs @@ -347,7 +347,10 @@ pub(crate) fn gen_update( /// load the field. pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> Result { let tv = gen_expr(cg, target)?; - let inferred = tv.inferred_type.as_ref().and_then(|ty| cg.prog.field_type(ty, field)); + let inferred = tv + .inferred_type + .as_ref() + .and_then(|ty| cg.prog.field_type(ty, field)); // Use the statically-known owner (a named record or an anonymous object // literal) when it actually declares `field`; otherwise (a generic accessor // whose parameter infers to a type variable) resolve the field by name across @@ -385,13 +388,19 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> // A handle field carries its ELEMENT's ABI, not an owner of its own: the // slot holds a runtime id, and `recv`/`await` on it needs the element type // to unbox with ([CONCURRENCY-CHANNEL]). - if let Some(handle) = inferred.as_ref().and_then(|ty| crate::builder::FiberSig::of(&cg.prog, ty)) - .or_else(|| cg.ctor_field_handle(&owner, field)) { + if let Some(handle) = inferred + .as_ref() + .and_then(|ty| crate::builder::FiberSig::of(&cg.prog, ty)) + .or_else(|| cg.ctor_field_handle(&owner, field)) + { let mut value = handle.restore(Value::new(loaded, fty)); value.inferred_type = inferred; return Ok(value); } - let owner = inferred.as_ref().map_or_else(|| cg.ctor_field_owner(&owner, field), |ty| crate::types::owner_name(&cg.prog, ty)); + let owner = inferred.as_ref().map_or_else( + || cg.ctor_field_owner(&owner, field), + |ty| crate::types::owner_name(&cg.prog, ty), + ); let mut value = Value::new(loaded, fty).with_owner(owner); value.inferred_type = inferred; Ok(value) diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs index 69a4ac10..4521483b 100644 --- a/crates/osprey-codegen/src/builder.rs +++ b/crates/osprey-codegen/src/builder.rs @@ -300,11 +300,12 @@ impl FiberSig { } } -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq)] pub(crate) struct ParamSig { pub(crate) ty: LType, pub(crate) result_inner: Option, pub(crate) fiber: Option, + pub(crate) inferred_type: Option, } impl ParamSig { @@ -315,11 +316,13 @@ impl ParamSig { ty: LType::Ptr, result_inner: Some(inner), fiber, + inferred_type: Some(ty.clone()), }, None => Self { ty: ltype_of(ty), result_inner: None, fiber, + inferred_type: Some(ty.clone()), }, } } @@ -702,7 +705,10 @@ impl Codegen { /// [TYPE-FN-HIGHER-ORDER]. pub(crate) fn callee_fn_type(&self, expr: &Expr) -> Option { match expr { - Expr::TypeApply { function, position, .. } => self.callee_fn_type(function) + Expr::TypeApply { + function, position, .. + } => self + .callee_fn_type(function) .map(|ty| self.prog.application_type(*position, &ty)), Expr::Identifier(name) => self.identifier_fn_type(name), // A call evaluates to its callee's return type — recurse so a chain diff --git a/crates/osprey-codegen/src/cast.rs b/crates/osprey-codegen/src/cast.rs index dbaafff7..6c1af255 100644 --- a/crates/osprey-codegen/src/cast.rs +++ b/crates/osprey-codegen/src/cast.rs @@ -96,23 +96,29 @@ pub(crate) fn incoming_param( sig: ParamSig, owner: Option, ) -> Value { + let owner = owner.or_else(|| { + sig.inferred_type + .as_ref() + .and_then(|ty| crate::types::owner_name(&cg.prog, ty)) + }); // A handle parameter's `owner` slot carries its ELEMENT's tag, not its own // — a fiber or channel id is a machine word with nothing to own. let (own_tag, elem_tag) = match sig.fiber { Some(_) => (None, owner), None => (owner, None), }; - let value = if let Some(inner) = sig.result_inner { + let mut value = if let Some(inner) = sig.result_inner { let struct_ty = crate::llty::result_struct_ty(inner); let typed = cg.emit_reg(format!("bitcast i8* {operand} to {struct_ty}*")); Value::result(typed, inner) } else { Value::new(operand, sig.ty).with_owner(own_tag) }; + value.inferred_type = sig.inferred_type; match sig.fiber { Some(fiber) => { let mut restored = fiber.restore(value); - restored.fiber_elem_owner = elem_tag; + restored.fiber_elem_owner = elem_tag.or(restored.fiber_elem_owner); restored } None => value, diff --git a/crates/osprey-codegen/src/closure.rs b/crates/osprey-codegen/src/closure.rs index 1c422b1a..3d8c750f 100644 --- a/crates/osprey-codegen/src/closure.rs +++ b/crates/osprey-codegen/src/closure.rs @@ -54,7 +54,10 @@ pub(crate) fn lambda_value( } let sig = Codegen::fn_value_sig(&cg.prog, ty) .ok_or_else(|| CodegenError::invalid("lambda has no inferred function type"))?; - emit_closure(cg, parameters, body, &sig) + let ty = ty.clone(); + let mut value = emit_closure(cg, parameters, body, &sig)?; + value.inferred_type = Some(ty); + Ok(value) } /// Emit a lambda as a closure value with the given signature (the consuming @@ -130,10 +133,7 @@ pub(crate) fn specialisation_key(target: &str, sig: &FnSig) -> String { let semantic_params = sig .0 .iter() - .map(|param| match param.result_inner { - Some(inner) => format!("Result<{inner}>"), - None => param.ty.to_string(), - }) + .map(|param| format!("{param:?}")) .collect::>() .join(","); format!( @@ -214,6 +214,9 @@ pub(crate) fn bind_params_from( for (i, (p, pty)) in parameters.iter().zip(param_tys).enumerate() { let reg = crate::llty::param_register(first + i); let value = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), None); + if let Some(ty) = &value.inferred_type { + cg.bind_fn_local(&p.name, ty.clone()); + } cg.bind(p.name.clone(), value); out.push((pty.ty, reg)); } @@ -236,6 +239,9 @@ pub(crate) fn reload_captures(cg: &mut Codegen, cell_ty: &str, caps: &[Capture]) let r = cg.emit_reg(format!("load {lty}, {lty}* {p}")); let mut v = c.val.clone(); v.operand = r; + if let Some(ty) = &v.inferred_type { + cg.bind_fn_local(&c.name, ty.clone()); + } cg.bind(c.name.clone(), v); } } @@ -373,7 +379,17 @@ pub(crate) fn cell_call_exprs( for e in exprs { vals.push(gen_expr(cg, e)?); } - let typed = coerce_closure_args(cg, sig, vals)?; + cell_call_values(cg, handle, sig, vals) +} + +/// Call using values already lowered against their semantic parameter types. +pub(crate) fn cell_call_values( + cg: &mut Codegen, + handle: &str, + sig: &FnSig, + values: Vec, +) -> Result { + let typed = coerce_closure_args(cg, sig, values)?; Ok(cell_call(cg, handle, sig, &typed)) } @@ -421,17 +437,37 @@ pub(crate) fn returned(reg: String, sig: &FnSig) -> Value { /// module) a forwarder that drops the env argument and tail-calls the real /// function, plus a constant cell pointing at it. pub(crate) fn named_fn_cell(cg: &mut Codegen, name: &str) -> Result { - if cg.fn_defs.contains_key(name) { - return Err(CodegenError::unsupported( - "a generic function as a function value", - )); + if let Some((parameters, body)) = cg.fn_defs.get(name).cloned() { + return specialized_named_cell(cg, name, ¶meters, &body); } let cell = match cg.fnval_cells.get(name) { Some(g) => g.clone(), None => emit_forwarder(cg, name)?, }; let reg = cg.emit_reg(format!("bitcast {{ i8* }}* {cell} to i8*")); - Ok(Value::new(reg, LType::Ptr)) + let mut value = Value::new(reg, LType::Ptr); + value.inferred_type = cg.callee_fn_type(&Expr::Identifier(name.to_owned())); + Ok(value) +} + +fn specialized_named_cell( + cg: &mut Codegen, + name: &str, + parameters: &[Parameter], + body: &Expr, +) -> Result { + let ty = cg.callee_fn_type(&Expr::Identifier(name.to_owned())); + let Some(ty) = ty.filter(crate::types::fn_value_concrete) else { + return Err(CodegenError::unsupported( + "a generic function as a function value", + )); + }; + let sig = Codegen::fn_value_sig(&cg.prog, &ty) + .ok_or_else(|| CodegenError::invalid("function value has no signature"))?; + let key = format!("{}|{ty:?}", specialisation_key(name, &sig)); + let mut value = emit_closure_keyed(cg, parameters, body, &sig, Some(key))?; + value.inferred_type = Some(ty); + Ok(value) } /// Emit `@__fnval_{name}` (env-dropping forwarder) and its constant cell; diff --git a/crates/osprey-codegen/src/curry.rs b/crates/osprey-codegen/src/curry.rs index d96da058..9a6e7b07 100644 --- a/crates/osprey-codegen/src/curry.rs +++ b/crates/osprey-codegen/src/curry.rs @@ -32,7 +32,12 @@ pub(crate) fn try_spine( arguments: &[Expr], named: &[NamedArgument], ) -> Result> { - let Some(Spine { head, application, mut groups }) = spine(function) else { + let Some(Spine { + head, + application, + mut groups, + }) = spine(function) + else { return Ok(None); }; if !cg.fn_defs.contains_key(head) { @@ -42,7 +47,9 @@ pub(crate) fn try_spine( let Some((first, rest)) = groups.split_first() else { return Ok(None); }; - crate::expr::with_application(cg, application, |cg| crate::genfn::try_inline(cg, head, first.0, first.1, rest)) + crate::expr::with_application(cg, application, |cg| { + crate::genfn::try_inline(cg, head, first.0, first.1, rest) + }) } /// Flatten an application spine into its head identifier and argument groups, @@ -53,10 +60,12 @@ fn spine(expr: &Expr) -> Option> { let mut application = None; loop { match node { - Expr::TypeApply { function, position, .. } => { + Expr::TypeApply { + function, position, .. + } => { application = *position; node = function; - }, + } Expr::Call { function, arguments, @@ -67,7 +76,11 @@ fn spine(expr: &Expr) -> Option> { } Expr::Identifier(name) => { groups.reverse(); - return Some(Spine { head: name, application, groups }); + return Some(Spine { + head: name, + application, + groups, + }); } _ => return None, } diff --git a/crates/osprey-codegen/src/effects.rs b/crates/osprey-codegen/src/effects.rs index f4e9d065..8656355c 100644 --- a/crates/osprey-codegen/src/effects.rs +++ b/crates/osprey-codegen/src/effects.rs @@ -41,6 +41,7 @@ impl OpSig { ty: LType::I64, result_inner: None, fiber: None, + inferred_type: None, } } diff --git a/crates/osprey-codegen/src/expr.rs b/crates/osprey-codegen/src/expr.rs index b37c5fc6..1b61d8b9 100644 --- a/crates/osprey-codegen/src/expr.rs +++ b/crates/osprey-codegen/src/expr.rs @@ -14,20 +14,40 @@ use osprey_ast::{Expr, InterpolatedPart, NamedArgument, Parameter, Position, Stm pub(crate) fn gen_expr(cg: &mut Codegen, expr: &Expr) -> Result { let inferred = match expr { - Expr::Integer(_) => Some(osprey_types::Type::con(osprey_types::names::INT, Vec::new())), - Expr::Float(_) => Some(osprey_types::Type::con(osprey_types::names::FLOAT, Vec::new())), - Expr::Bool(_) => Some(osprey_types::Type::con(osprey_types::names::BOOL, Vec::new())), - Expr::Str(_) | Expr::InterpolatedStr(_) => Some(osprey_types::Type::con(osprey_types::names::STRING, Vec::new())), + Expr::Integer(_) => Some(osprey_types::Type::con( + osprey_types::names::INT, + Vec::new(), + )), + Expr::Float(_) => Some(osprey_types::Type::con( + osprey_types::names::FLOAT, + Vec::new(), + )), + Expr::Bool(_) => Some(osprey_types::Type::con( + osprey_types::names::BOOL, + Vec::new(), + )), + Expr::Str(_) | Expr::InterpolatedStr(_) => Some(osprey_types::Type::con( + osprey_types::names::STRING, + Vec::new(), + )), Expr::Call { function, .. } => cg.callee_fn_type(function).and_then(|ty| match ty { osprey_types::Type::Fun { ret, .. } => Some(*ret), _ => None, }), - Expr::List(_, position) => cg.prog.list_elem_type(*position).cloned().map(|element| osprey_types::Type::con(osprey_types::names::LIST, vec![element])), - Expr::Perform { position, .. } => position.and_then(|p| cg.prog.performs.get(&(p.line, p.column))).map(|site| site.op.ret.clone()), + Expr::List(_, position) => cg + .prog + .list_elem_type(*position) + .cloned() + .map(|element| osprey_types::Type::con(osprey_types::names::LIST, vec![element])), + Expr::Perform { position, .. } => position + .and_then(|p| cg.prog.performs.get(&(p.line, p.column))) + .map(|site| site.op.ret.clone()), _ => None, }; let mut value = gen_expr_raw(cg, expr)?; - if let Some(ty) = inferred.filter(|ty| !osprey_types::has_type_var(ty)) { value.inferred_type = Some(ty); } + if let Some(ty) = inferred.filter(|ty| !osprey_types::has_type_var(ty)) { + value.inferred_type = Some(ty); + } Ok(value) } @@ -67,7 +87,9 @@ fn gen_expr_raw(cg: &mut Codegen, expr: &Expr) -> Result { None => Err(CodegenError::unknown(name)), }, }, - Expr::TypeApply { function, .. } => gen_expr(cg, function), + Expr::TypeApply { + function, position, .. + } => with_application(cg, *position, |cg| gen_expr(cg, function)), Expr::Binary { op, left, right } => gen_binary(cg, op, left, right), Expr::Unary { op, operand } => gen_unary(cg, op, operand), Expr::Call { @@ -75,6 +97,12 @@ fn gen_expr_raw(cg: &mut Codegen, expr: &Expr) -> Result { arguments, named_arguments, } => gen_call(cg, function, arguments, named_arguments), + Expr::MethodCall { + target, + method, + arguments, + named_arguments, + } => gen_method_call(cg, target, method, arguments, named_arguments), Expr::Match { value, arms } => gen_match(cg, value, arms), Expr::Block { statements, value } => gen_block(cg, statements, value.as_deref()), Expr::TypeConstructor { name, fields, .. } => { @@ -821,18 +849,80 @@ const BUILTIN_DISPATCH: [BuiltinDispatch; 8] = [ ]; pub(crate) fn unapplied(mut expression: &Expr) -> &Expr { - while let Expr::TypeApply { function, .. } = expression { expression = function; } + while let Expr::TypeApply { function, .. } = expression { + expression = function; + } expression } -pub(crate) fn with_application(cg: &mut Codegen, position: Option, generate: impl FnOnce(&mut Codegen) -> R) -> R { - let bindings = position.and_then(|p| cg.prog.applications.get(&(p.line, p.column))).cloned(); +pub(crate) fn with_application( + cg: &mut Codegen, + position: Option, + generate: impl FnOnce(&mut Codegen) -> R, +) -> R { + let bindings = position + .and_then(|p| cg.prog.applications.get(&(p.line, p.column))) + .cloned(); let original = bindings.map(|b| { let specialized = cg.prog.specialized(&b); std::mem::replace(&mut cg.prog, specialized) }); let result = generate(cg); - if let Some(original) = original { cg.prog = original; } + if let Some(original) = original { + cg.prog = original; + } + result +} + +/// Deferred generic dotted calls select against the instantiated receiver. +/// Binding its value before selecting also guarantees exactly one evaluation. +fn gen_method_call( + cg: &mut Codegen, + target: &Expr, + method: &str, + arguments: &[Expr], + named: &[NamedArgument], +) -> Result { + let receiver = gen_expr(cg, target)?; + let source = osprey_ast::symbol::demangle(method).unwrap_or_else(|| method.to_owned()); + let field = source.rsplit("::").next().unwrap_or(&source); + let has_field = receiver + .inferred_type + .as_ref() + .and_then(|ty| cg.prog.field_type(ty, field)) + .is_some() + || receiver + .osp_ty + .as_ref() + .and_then(|owner| cg.prog.ctors.get(owner)) + .is_some_and(|ctor| ctor.fields.iter().any(|(name, _)| name == field)); + let temporary = osprey_ast::generated_name("method_receiver", 0); + if !has_field + && !cg.fn_params.contains_key(method) + && !cg.prog.functions.contains_key(method) + && !cg.call_aliases.contains_key(method) + && !cg.module_globals.contains_key(method) + && cg.lambda_def(method).is_none() + && cg.lookup(method).is_none() + && osprey_types::builtin_signature(method).is_none() + { + return Err(CodegenError::unsupported("method call")); + } + let target = Expr::Identifier(temporary.clone()); + let mut arguments = arguments.to_vec(); + let function = if has_field { + Expr::FieldAccess { + target: Box::new(target), + field: field.to_owned(), + } + } else { + arguments.insert(0, target); + Expr::Identifier(method.to_owned()) + }; + cg.push_scope(); + cg.bind(temporary, receiver); + let result = gen_call(cg, &function, &arguments, named); + cg.pop_scope(); result } @@ -842,7 +932,10 @@ fn gen_call( arguments: &[Expr], named: &[NamedArgument], ) -> Result { - if let Expr::TypeApply { function, position, .. } = function { + if let Expr::TypeApply { + function, position, .. + } = function + { return with_application(cg, *position, |cg| gen_call(cg, function, arguments, named)); } // A directly-applied lambda (`x |> fn(y) => …`, `(fn(y) => …)(x)`) is @@ -876,7 +969,7 @@ fn gen_call( .as_ref() .and_then(|t| Codegen::fn_value_sig(&cg.prog, t)); if let Some(sig) = sig { - return call_fn_value(cg, function, &sig, arguments, named); + return call_fn_value(cg, function, Some(&sig), arguments, named); } } } @@ -885,14 +978,11 @@ fn gen_call( // application (`add3(1)(2)(3)`) or a function held in a record field. // Recover its signature from the type table and dispatch through the // closure cell; fail loudly only when the callee is not a function value. - if let Some(sig) = cg + let sig = cg .callee_fn_type(function) .as_ref() - .and_then(|t| Codegen::fn_value_sig(&cg.prog, t)) - { - return call_fn_value(cg, function, &sig, arguments, named); - } - return Err(CodegenError::unsupported("indirect / higher-order call")); + .and_then(|t| Codegen::fn_value_sig(&cg.prog, t)); + return call_fn_value(cg, function, sig.as_ref(), arguments, named); }; // A function-valued parameter (bound while inlining a generic function) // redirects to its real callee, so `f(x)` becomes `toString(x)` / `addOne(x)`. @@ -975,13 +1065,38 @@ fn gen_call( fn call_fn_value( cg: &mut Codegen, callee: &Expr, - sig: &FnSig, + sig: Option<&FnSig>, arguments: &[Expr], named: &[NamedArgument], ) -> Result { let handle = gen_expr(cg, callee)?; + // Generic constructor layouts retain erased field templates. The loaded + // closure carries its instantiated type, including float returns and the + // function types of callback parameters. + let semantic = handle.inferred_type.as_ref(); + let actual = semantic.and_then(|ty| Codegen::fn_value_sig(&cg.prog, ty)); + let sig = actual + .as_ref() + .or(sig) + .ok_or_else(|| CodegenError::unsupported("indirect / higher-order call"))?; + let slots: Vec<_> = match semantic { + Some(osprey_types::Type::Fun { params, .. }) => params + .iter() + .map(|ty| Codegen::fn_value_sig(&cg.prog, ty)) + .collect(), + _ => Vec::new(), + }; let exprs = arg_exprs(arguments, named); - crate::closure::cell_call_exprs(cg, &handle.operand, sig, &exprs) + let values = exprs + .iter() + .enumerate() + .map(|(i, expr)| eval_arg(cg, expr, slots.get(i).and_then(Option::as_ref), false)) + .collect::>>()?; + let mut result = crate::closure::cell_call_values(cg, &handle.operand, sig, values)?; + if let Some(osprey_types::Type::Fun { ret, .. }) = semantic { + result.inferred_type = Some((**ret).clone()); + } + Ok(result) } /// Beta-reduce a lambda at its application site: bind each parameter to its @@ -1291,20 +1406,27 @@ fn ordered_args( if let Some(pnames) = cg.fn_params.get(name).cloned() { let mut out = Vec::new(); for (i, pn) in pnames.iter().enumerate() { - if let Some(na) = named.iter().find(|a| &a.name == pn) { + if let Some(argument) = arguments + .get(i) + .or_else(|| named.iter().find(|a| &a.name == pn).map(|a| &a.value)) + { out.push(eval_arg( cg, - &na.value, + argument, sigs.get(i).and_then(Option::as_ref), ffi, )?); } } - if out.len() == named.len() { + if out.len() == arguments.len() + named.len() { return Ok(out); } } - return named.iter().map(|na| gen_expr(cg, &na.value)).collect(); + return arguments + .iter() + .chain(named.iter().map(|na| &na.value)) + .map(|argument| gen_expr(cg, argument)) + .collect(); } arguments .iter() @@ -1320,6 +1442,12 @@ fn ordered_args( /// Everything else goes through `gen_expr` (where a user function name becomes /// its forwarder cell). fn eval_arg(cg: &mut Codegen, expr: &Expr, sig: Option<&FnSig>, ffi: bool) -> Result { + if let Expr::TypeApply { + function, position, .. + } = expr + { + return with_application(cg, *position, |cg| eval_arg(cg, function, sig, ffi)); + } match (expr, sig) { ( Expr::Lambda { diff --git a/crates/osprey-codegen/src/extern_call.rs b/crates/osprey-codegen/src/extern_call.rs index b34abc97..c23875d7 100644 --- a/crates/osprey-codegen/src/extern_call.rs +++ b/crates/osprey-codegen/src/extern_call.rs @@ -141,21 +141,34 @@ fn eval_args( .zip(crate::expr::arg_exprs(args, named)) .enumerate() .map(|(index, (want, e))| { - let v = match e { - Expr::Identifier(n) - if *want == LType::Ptr - && cg.lookup(n).is_none() - && cg.fn_params.contains_key(n) => - { - callback_pointer(cg, n, name, index)? - } - _ => gen_expr(cg, e)?, - }; + let v = argument_value(cg, e, *want, name, index)?; Ok(crate::cast::coerce_to(cg, v, *want)?.operand) }) .collect() } +fn argument_value( + cg: &mut Codegen, + expr: &Expr, + want: LType, + name: &str, + index: usize, +) -> Result { + match expr { + Expr::TypeApply { + function, position, .. + } => crate::expr::with_application(cg, *position, |cg| { + argument_value(cg, function, want, name, index) + }), + Expr::Identifier(n) + if want == LType::Ptr && cg.lookup(n).is_none() && cg.fn_params.contains_key(n) => + { + callback_pointer(cg, n, name, index) + } + _ => gen_expr(cg, expr), + } +} + /// The raw code pointer for a callback argument. A handler whose types are /// INFERRED is generic and has no `@name` symbol of its own, so pointing at one /// emitted IR that references a body codegen never defined — reported as diff --git a/crates/osprey-codegen/src/fiber.rs b/crates/osprey-codegen/src/fiber.rs index 34929cc5..ce29bda1 100644 --- a/crates/osprey-codegen/src/fiber.rs +++ b/crates/osprey-codegen/src/fiber.rs @@ -57,6 +57,9 @@ pub(crate) fn gen_spawn(cg: &mut Codegen, e: &Expr) -> Result { /// can tag the handle for `await` to unbox. fn thunk_body(cg: &mut Codegen, e: &Expr) -> Result { let v = gen_expr(cg, e)?; + // Await restores the runtime list ABI, so materialize an inlined generic + // call's literal result before its pointer crosses the fiber boundary. + let v = crate::listlit::escaping(cg, v); let elem = v.clone(); // The result escapes boxed across the fiber boundary: dup it before the // thunk's owners drop, so the runtime's completed-result slot holds +1 diff --git a/crates/osprey-codegen/src/genfn.rs b/crates/osprey-codegen/src/genfn.rs index 95eddec1..0f7c0afe 100644 --- a/crates/osprey-codegen/src/genfn.rs +++ b/crates/osprey-codegen/src/genfn.rs @@ -222,11 +222,11 @@ fn pair_args<'a>( } else { params .iter() - .filter_map(|p| { - named - .iter() - .find(|n| n.name == p.name) - .map(|n| (p, &n.value)) + .enumerate() + .filter_map(|(index, p)| { + args.get(index) + .or_else(|| named.iter().find(|n| n.name == p.name).map(|n| &n.value)) + .map(|argument| (p, argument)) }) .collect() } diff --git a/crates/osprey-codegen/src/gpu_kernel.rs b/crates/osprey-codegen/src/gpu_kernel.rs index 6db048ec..3134a351 100644 --- a/crates/osprey-codegen/src/gpu_kernel.rs +++ b/crates/osprey-codegen/src/gpu_kernel.rs @@ -275,6 +275,7 @@ fn param_sigs(parameters: &[Parameter], own: Option<&FnSig>, slots: &[LType]) -> ty: slots.get(i).copied().unwrap_or(LType::I64), result_inner: None, fiber: None, + inferred_type: None, }, }) .collect() @@ -332,6 +333,7 @@ fn bind_uniforms(cg: &mut Codegen, caps: &[crate::closure::Capture]) -> Vec<(LTy ty: c.val.ty, result_inner: None, fiber: None, + inferred_type: c.val.inferred_type.clone(), }; // `incoming_param` registers no ownership: a uniform buffer handle is // BORROWED for the call's duration, exactly as a top-level function's diff --git a/crates/osprey-codegen/src/lower.rs b/crates/osprey-codegen/src/lower.rs index 36f929c7..c7646ee2 100644 --- a/crates/osprey-codegen/src/lower.rs +++ b/crates/osprey-codegen/src/lower.rs @@ -279,6 +279,7 @@ fn gen_function( ty: LType::I64, result_inner: None, fiber: None, + inferred_type: None, }, None, ); @@ -308,7 +309,11 @@ fn gen_function( for (i, (p, (pty, owner))) in parameters.iter().zip(param_sig.iter()).enumerate() { let reg = crate::llty::param_register(i); let mut v = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), owner.clone()); - v.inferred_type = cg.prog.param_types(name).and_then(|types| types.get(i)).cloned(); + v.inferred_type = cg + .prog + .param_types(name) + .and_then(|types| types.get(i)) + .cloned(); cg.emit_debug_param(&p.name, &v); cg.bind(p.name.clone(), v); params.push((pty.ty, reg)); diff --git a/crates/osprey-codegen/src/monofn.rs b/crates/osprey-codegen/src/monofn.rs index f31d1bab..bc1db4e0 100644 --- a/crates/osprey-codegen/src/monofn.rs +++ b/crates/osprey-codegen/src/monofn.rs @@ -237,6 +237,7 @@ fn param_of(v: &Value) -> ParamSig { ty: v.ty, result_inner: v.result_inner, fiber: None, + inferred_type: v.inferred_type.clone(), } } @@ -256,6 +257,9 @@ fn bind_params( // the call's duration, exactly as a top-level function's are // [GC-ARC-PERCEUS]. let value = crate::cast::incoming_param(cg, format!("%{reg}"), sig.clone(), owner.clone()); + if let Some(ty) = &value.inferred_type { + cg.bind_fn_local(&p.name, ty.clone()); + } cg.bind(p.name.clone(), value); out.push((sig.ty, reg)); } diff --git a/crates/osprey-codegen/src/stmt.rs b/crates/osprey-codegen/src/stmt.rs index a7a840fd..71e220ff 100644 --- a/crates/osprey-codegen/src/stmt.rs +++ b/crates/osprey-codegen/src/stmt.rs @@ -289,7 +289,11 @@ fn gen_bind(cg: &mut Codegen, name: &str, value: &Expr, position: Option bool { /// uses it to keep inlined function-typed parameters callable. pub(crate) fn fn_result_type(cg: &Codegen, value: &Expr) -> Option { match value { + Expr::TypeApply { .. } => cg + .callee_fn_type(value) + .filter(crate::types::fn_value_concrete), Expr::Lambda { position, .. } => cg .prog .lambda_type(*position) diff --git a/crates/osprey-codegen/src/types.rs b/crates/osprey-codegen/src/types.rs index f3754a5f..0aee19b3 100644 --- a/crates/osprey-codegen/src/types.rs +++ b/crates/osprey-codegen/src/types.rs @@ -97,9 +97,18 @@ pub(crate) fn result_payload_owner(prog: &ProgramTypes, ty: &Type) -> Option Option { match ty { - Type::Record { name, fields } if prog.ctors.get(name).is_some_and(|layout| !layout.type_params.is_empty()) => { + Type::Record { name, fields } + if prog + .ctors + .get(name) + .is_some_and(|layout| !layout.type_params.is_empty()) => + { let layout = prog.ctors.get(name)?; - let shape: Option> = layout.fields.iter().map(|(field, _)| fields.get(field).map(|ty| ltype_of(ty).as_str())).collect(); + let shape: Option> = layout + .fields + .iter() + .map(|(field, _)| fields.get(field).map(|ty| ltype_of(ty).as_str())) + .collect(); shape.map(|shape| format!("{name}#{}", shape.join(","))) } Type::Record { name, .. } | Type::Union { name, .. } => Some(name.clone()), @@ -154,7 +163,11 @@ pub(crate) fn record_shape(prog: &ProgramTypes, name: &str, args: &[Type]) -> Op if !layout.owner_is_record || layout.type_params.is_empty() { return None; } - let shape: Vec<&str> = layout.fields.iter().map(|(_, t)| ltype_of(&substituted(t, args)).as_str()).collect(); + let shape: Vec<&str> = layout + .fields + .iter() + .map(|(_, t)| ltype_of(&substituted(t, args)).as_str()) + .collect(); Some(format!("{name}#{}", shape.join(","))) } diff --git a/crates/osprey-lsp/src/analysis.rs b/crates/osprey-lsp/src/analysis.rs index e9600dde..5f7ff740 100644 --- a/crates/osprey-lsp/src/analysis.rs +++ b/crates/osprey-lsp/src/analysis.rs @@ -252,7 +252,10 @@ fn walk_expr(e: &Expr, prefix: &[String], out: &mut Vec) { walk_expr(left, prefix, out); walk_expr(right, prefix, out); } - Expr::Unary { operand, .. } => walk_expr(operand, prefix, out), + Expr::TypeApply { + function: operand, .. + } + | Expr::Unary { operand, .. } => walk_expr(operand, prefix, out), other => walk_expr_rest(other, prefix, out), } } diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs index 4314064b..d66c7e8d 100644 --- a/crates/osprey-lsp/src/diagnostics.rs +++ b/crates/osprey-lsp/src/diagnostics.rs @@ -118,9 +118,19 @@ fn type_diagnostics( }) .collect(); if diagnostics.is_empty() { - diagnostics.extend(osprey_types::redundant_annotations(program).into_iter().map(|raised| { - warning(source, raised.position.unwrap_or(Position { line: 1, column: 0 }), &raised.message, raised.rule, encoding) - })); + diagnostics.extend( + osprey_types::redundant_annotations(program) + .into_iter() + .map(|raised| { + warning( + source, + raised.position.unwrap_or(Position { line: 1, column: 0 }), + &raised.message, + raised.rule, + encoding, + ) + }), + ); } diagnostics } @@ -226,11 +236,30 @@ fn assembled_type_errors( }) .collect(); if errors.is_empty() { - diagnostics.extend(osprey_types::redundant_annotations(&project.program).into_iter().filter_map(|raised| { - let global = raised.position?; - let (owner, line) = project.source_at_line(global.line)?; - same_path(&owner.path, file).then(|| warning(source, Position { line, column: global.column }, &raised.message, raised.rule, encoding)) - })); + diagnostics.extend( + osprey_types::redundant_annotations_where(&project.program, |position| { + position + .and_then(|p| project.source_at_line(p.line)) + .is_some_and(|(owner, _)| same_path(&owner.path, file)) + }) + .into_iter() + .filter_map(|raised| { + let global = raised.position?; + let (owner, line) = project.source_at_line(global.line)?; + same_path(&owner.path, file).then(|| { + warning( + source, + Position { + line, + column: global.column, + }, + &raised.message, + raised.rule, + encoding, + ) + }) + }), + ); } diagnostics } diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs index ef25a22c..a957d651 100644 --- a/crates/osprey-project/src/rewrite.rs +++ b/crates/osprey-project/src/rewrite.rs @@ -294,6 +294,9 @@ impl Resolver<'_> { .. } => { self.rewrite_expr(function, context, locals); + if let Expr::FieldAccess { field, .. } = function.as_mut() { + self.rewrite_value_name(field, context, false); + } for argument in type_args { self.rewrite_type(argument, context, locals); } diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index 43482af5..d4353250 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -212,16 +212,11 @@ impl Lowerer<'_> { index: Box::new(self.lower_expr(index)), }; } - // function/method call. UFCS [BUILTIN-STRING-UFCS]: `x.f(a, …)` is - // sugar for `f(x, a, …)`, so a - // field-access callee lowers to an ordinary call with the receiver as the - // first positional argument — keeping method calls invisible downstream. - let (mut arguments, named_arguments) = self.lower_arg_list(node); + // Keep an ordinary dotted call until inference can distinguish a + // callable record field from receiver-first sugar [BUILTIN-STRING-UFCS]. + // Written type arguments apply a named function's declared binders. + let (arguments, named_arguments) = self.lower_arg_list(node); if let Some(args) = node.child_by_field_name("type_arguments") { - if let Expr::FieldAccess { target, field } = callee { - arguments.insert(0, *target); - callee = Expr::Identifier(field); - } callee = Expr::TypeApply { function: Box::new(callee), type_args: self @@ -233,14 +228,12 @@ impl Lowerer<'_> { }; } match callee { - Expr::FieldAccess { target, field } => { - arguments.insert(0, *target); - Expr::Call { - function: Box::new(Expr::Identifier(field)), - arguments, - named_arguments, - } - } + Expr::FieldAccess { target, field } => Expr::MethodCall { + target, + method: field, + arguments, + named_arguments, + }, // A saturated call of a positionally-declared constructor is a // construction, not a call ([TYPE-UNION-POSITIONAL]) — the one // call-shaped expression exempt from the named-argument rule, diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index 9fbb4d27..e72e64d5 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -310,7 +310,7 @@ impl ItemLower { type_params, ty, effects, - .. + pos, } = item { self.pending = Some(MlSig { @@ -318,6 +318,7 @@ impl ItemLower { type_params, ty, effects, + position: pos, }); } } @@ -645,9 +646,9 @@ pub(super) fn lower_binding( let body = in_scope(params_scope(¶ms), move || lower_expr(body)); // Split the paired signature into its type params, declared type and // effect row. - let (type_params, ty, effects) = match sig { - Some(s) => (s.type_params, Some(s.ty), s.effects), - None => (Vec::new(), None, Vec::new()), + let (type_params, ty, effects, signature_position) = match sig { + Some(s) => (s.type_params, Some(s.ty), s.effects, Some(s.position)), + None => (Vec::new(), None, Vec::new(), None), }; let ty = ty.as_ref(); if let Some(message) = ty.and_then(|t| signature_mismatch(&name, ¶ms, uncurried, t)) { @@ -668,9 +669,9 @@ pub(super) fn lower_binding( }; } let (parameters, body, return_type) = if uncurried { - build_function_flat(params, body, ty) + build_function_flat(params, body, ty, pos, signature_position) } else { - build_function(params, body, ty, pos) + build_function(params, body, ty, pos, signature_position) }; Stmt::Function { name, @@ -684,6 +685,33 @@ pub(super) fn lower_binding( } } +/// A header and an inline parameter annotation are independent constraints. +/// Check the inline type immediately inside that parameter's binder, before a +/// later curry parameter can shadow its name. +fn inline_param_constraint( + param: Option<&MlParam>, + index: usize, + pos: Position, + signed: bool, + body: Expr, +) -> Expr { + let (true, Some(MlParam::Typed(name, ty))) = (signed, param) else { + return body; + }; + let name = parameter_name(name.clone(), index); + Expr::Block { + statements: vec![Stmt::Let { + value: Expr::Identifier(name.clone()), + name, + mutable: false, + ty: type_expr(ty), + doc: None, + position: Some(pos), + }], + value: Some(Box::new(body)), + } +} + /// A paired signature the lowering cannot honour, as a diagnostic — or `None` /// when every written type survives into the canonical AST. Guards the silent /// drops in [`build_function_flat`]/[`build_function`]: a tuple domain whose @@ -747,6 +775,7 @@ pub(super) struct MlSig { type_params: Vec, ty: MlType, effects: Vec, + position: Position, } impl MlSig { @@ -755,12 +784,14 @@ impl MlSig { type_params: Vec, ty: MlType, effects: Vec, + position: Position, ) -> Self { Self { name, type_params, ty, effects, + position, } } } @@ -802,18 +833,26 @@ fn build_function_flat( params: Vec, body: Expr, sig: Option<&MlType>, + pos: Position, + signature_position: Option, ) -> (Vec, Expr, Option) { let spine = expand_tuple_head(sig.map(arrow_spine).unwrap_or_default(), params.len()); let consumed = params.len(); + let body = params.iter().enumerate().rev().fold(body, |body, (i, p)| { + inline_param_constraint(Some(p), i, curry_position(pos, i), sig.is_some(), body) + }); let parameters = params .into_iter() .enumerate() - .filter_map(|(i, p)| lower_param(p, i, spine.get(i))) + .filter_map(|(i, p)| lower_param(p, i, spine.get(i), signature_position)) .collect(); ( parameters, body, - arrow_of(spine.get(consumed..).unwrap_or(&[])), + signature_annotation( + arrow_of(spine.get(consumed..).unwrap_or(&[])), + signature_position, + ), ) } @@ -891,18 +930,31 @@ fn build_function( body: Expr, sig: Option<&MlType>, pos: Position, + signature_position: Option, ) -> (Vec, Expr, Option) { let spine = sig.map(arrow_spine).unwrap_or_default(); let mut rest = params.into_iter(); let first = rest.next(); // `()` (unit marker) or no parameter binds nothing. let parameters = first - .and_then(|p| lower_param(p, 0, spine.first())) + .clone() + .and_then(|p| lower_param(p, 0, spine.first(), signature_position)) .into_iter() .collect(); let tail_spine = spine.get(1..).unwrap_or(&[]); - let body = curry_params(rest.collect(), body, tail_spine, pos); - (parameters, body, arrow_of(tail_spine)) + let body = curry_params(rest.collect(), body, tail_spine, pos, signature_position); + let body = inline_param_constraint( + first.as_ref(), + 0, + curry_position(pos, 0), + sig.is_some(), + body, + ); + ( + parameters, + body, + signature_annotation(arrow_of(tail_spine), signature_position), + ) } /// Fold a surface parameter list into a right-nested chain of one-parameter @@ -911,21 +963,44 @@ fn build_function( /// positionally; the lambda for the i-th parameter returns the function-typed /// tail `arrow_of(spine[i+1..])`. An empty parameter list returns `body` /// unchanged (the curried tail of a single-parameter function is just its body). -fn curry_params(params: Vec, body: Expr, spine: &[MlType], pos: Position) -> Expr { +fn curry_params( + params: Vec, + body: Expr, + spine: &[MlType], + pos: Position, + signature_position: Option, +) -> Expr { let mut acc = body; for (i, param) in params.into_iter().enumerate().rev() { + let body = inline_param_constraint( + Some(¶m), + i, + curry_position(pos, i.saturating_add(1)), + signature_position.is_some(), + acc, + ); acc = Expr::Lambda { - parameters: curry_parameter(param, i, spine.get(i)), - return_type: arrow_of(spine.get(i + 1..).unwrap_or(&[])), - body: Box::new(acc), + parameters: lower_param(param, i, spine.get(i), signature_position) + .into_iter() + .collect(), + return_type: signature_annotation( + arrow_of(spine.get(i + 1..).unwrap_or(&[])), + signature_position, + ), + body: Box::new(body), position: Some(curry_position(pos, i)), }; } acc } -fn curry_parameter(param: MlParam, index: usize, inferred: Option<&MlType>) -> Vec { - lower_param(param, index, inferred).into_iter().collect() +/// Every lowered fragment of one written signature keeps the same source +/// identity, so diagnostics erase that annotation as one unit. +fn signature_annotation(ty: Option, position: Option) -> Option { + ty.map(|mut ty| { + ty.position = position; + ty + }) } /// The surface spelling of an ignored parameter ([PARAM-WILDCARD]). @@ -936,22 +1011,40 @@ const WILDCARD: &str = "_"; /// name for its slot ([PARAM-WILDCARD]) so repeated `_`s in one head cannot /// collide and none of them is referenceable from the body. This is the single /// definition of the mapping; every head form routes through it. -fn lower_param(param: MlParam, index: usize, inferred: Option<&MlType>) -> Option { +fn lower_param( + param: MlParam, + index: usize, + inferred: Option<&MlType>, + signature_position: Option, +) -> Option { let (name, ty) = match param { - MlParam::Named(name) => (name, inferred.and_then(type_expr)), - MlParam::Typed(name, ty) => (name, type_expr(&ty)), + MlParam::Named(name) => ( + name, + signature_annotation(inferred.and_then(type_expr), signature_position), + ), + MlParam::Typed(name, ty) => ( + name, + inferred.map_or_else( + || type_expr(&ty), + |written| signature_annotation(type_expr(written), signature_position), + ), + ), MlParam::Unit => return None, // [`super::clauses::merge`] rewrites every clause set before lowering, // so a surviving head pattern is one the merge already diagnosed; // bind it to an unreferenceable name and let that error stand. MlParam::Pattern(_) => (osprey_ast::clause_param_name(index), None), }; - let name = if name == WILDCARD { + let name = parameter_name(name, index); + Some(Parameter { name, ty }) +} + +fn parameter_name(name: String, index: usize) -> String { + if name == WILDCARD { osprey_ast::wildcard_param_name(index) } else { name - }; - Some(Parameter { name, ty }) + } } /// Give every synthesized curry lambda its own `ProgramTypes::lambdas` key; @@ -975,7 +1068,7 @@ fn flat_params(params: Vec) -> Vec { params .into_iter() .enumerate() - .filter_map(|(i, p)| lower_param(p, i, None)) + .filter_map(|(i, p)| lower_param(p, i, None, None)) .collect() } @@ -988,7 +1081,7 @@ fn lower_lambda(params: Vec, body: Expr, pos: Position) -> Expr { position: Some(pos), }; } - curry_params(params, body, &[], pos) + curry_params(params, body, &[], pos, None) } /// Flatten the top-level arrow spine of a type: `a -> b -> c` ⇒ `[a, b, c]`, @@ -1414,7 +1507,6 @@ fn parse_fragment(frag: &str) -> Expr { _ => Expr::Identifier(frag.trim().to_owned()), } } - #[cfg(test)] #[expect( clippy::indexing_slicing, diff --git a/crates/osprey-syntax/src/ml/module_lower.rs b/crates/osprey-syntax/src/ml/module_lower.rs index 528ec394..4bab8650 100644 --- a/crates/osprey-syntax/src/ml/module_lower.rs +++ b/crates/osprey-syntax/src/ml/module_lower.rs @@ -39,8 +39,8 @@ impl ModuleLower { type_params, ty, effects, - .. - } => self.pending = Some((MlSig::new(name, type_params, ty, effects), visibility)), + pos, + } => self.pending = Some((MlSig::new(name, type_params, ty, effects, pos), visibility)), MlItem::Binding { mutable, name, diff --git a/crates/osprey-types/src/applications.rs b/crates/osprey-types/src/applications.rs index f3476451..ddc80d20 100644 --- a/crates/osprey-types/src/applications.rs +++ b/crates/osprey-types/src/applications.rs @@ -66,20 +66,27 @@ pub(crate) fn collect( let site = match expression { Expr::Call { function, .. } => Some(function.as_ref()), Expr::Pipe { right, .. } => Some(right.as_ref()), + Expr::MethodCall { .. } | Expr::Identifier(_) | Expr::Path(_) => Some(expression), _ => None, }; if let Some(bindings) = site - .filter(|e| matches!(e, Expr::Identifier(_) | Expr::Path(_))) + .filter(|e| { + matches!( + e, + Expr::Identifier(_) | Expr::Path(_) | Expr::MethodCall { .. } + ) + }) .and_then(|e| self.sites.get(&std::ptr::from_ref(e).addr())) .filter(|b| !b.is_empty()) { - let _ = self.calls.insert( - self.index, - bindings - .iter() - .map(|(v, t)| (*v, self.ctx.apply(t))) - .collect(), - ); + let bindings: Bindings = bindings + .iter() + .map(|(v, t)| (*v, self.ctx.apply(t))) + .collect(); + let standalone = matches!(expression, Expr::Identifier(_) | Expr::Path(_)); + if !standalone || bindings.values().all(|ty| !crate::has_type_var(ty)) { + let _ = self.calls.insert(self.index, bindings); + } } self.index += 1; } @@ -115,7 +122,7 @@ pub(crate) fn elaborate(program: &Program, types: &mut ProgramTypes) -> Program let mut index = 0; for statement in &mut result.statements { osprey_ast::mutate::statement_children_mut(statement, &mut |e| { - elaborate_expr(e, &mut index, types) + elaborate_expr(e, &mut index, types); }); } result @@ -125,12 +132,36 @@ fn elaborate_expr(expression: &mut Expr, index: &mut usize, types: &mut ProgramT let current = *index; *index += 1; osprey_ast::mutate::children_mut(expression, &mut |child| elaborate_expr(child, index, types)); + if let Some(target) = types.methods.get(¤t) { + crate::methods::lower(expression, target); + } let Some(bindings) = types.call_bindings.get(¤t).cloned() else { return; }; let Ok(column) = u32::try_from(current) else { return; }; + if matches!(expression, Expr::Identifier(_) | Expr::Path(_)) { + let _ = types.applications.insert((0, column), bindings); + *expression = Expr::TypeApply { + function: Box::new(expression.clone()), + type_args: Vec::new(), + position: Some(Position { line: 0, column }), + }; + return; + } + if matches!( + types.methods.get(¤t), + Some(crate::methods::Target::Deferred(_)) + ) { + let _ = types.applications.insert((0, column), bindings); + *expression = Expr::TypeApply { + function: Box::new(expression.clone()), + type_args: Vec::new(), + position: Some(Position { line: 0, column }), + }; + return; + } let function = match expression { Expr::Call { function, .. } => function, Expr::Pipe { right, .. } => right, diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 1714019e..e46428a1 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -103,6 +103,15 @@ impl Discard { } } +/// Generated wildcard binders still name the source `_` in diagnostics. +pub(crate) fn annotation_name(name: &str) -> String { + if name.starts_with("$wild") { + "_".to_owned() + } else { + name.to_owned() + } +} + /// All cross-cutting declaration tables, plus the inference context. pub struct Checker { pub(crate) ctx: InferCtx, @@ -131,12 +140,16 @@ pub struct Checker { pub(crate) list_tys: Vec<(Position, Type)>, /// Fresh substitutions at value uses, retained for the effect proof. pub(crate) instantiations: HashMap>, + /// Dotted call identity: a field name, or receiver-first function dispatch. + pub(crate) methods: crate::methods::Targets, /// Explicit applications have stable source positions for backend cloning. pub(crate) application_tys: Vec<(Position, HashMap)>, /// Concrete arguments passed to representation-sensitive built-ins. These /// are validated after inference so a variable constrained later in the /// same body is checked at its final type. pub(crate) builtin_uses: Vec<(String, Type)>, + /// Generalized constraints remain part of each source binding's contract. + scheme_obligations: HashMap>, /// Every discarded value, where it was written, and whether the author said /// so with `let _ =`. Validated after inference for the same reason /// `builtin_uses` is. Implements [BLOCK-DISCARD]. @@ -193,8 +206,10 @@ impl Checker { let_tys: Vec::new(), list_tys: Vec::new(), instantiations: HashMap::new(), + methods: HashMap::new(), application_tys: Vec::new(), builtin_uses: Vec::new(), + scheme_obligations: HashMap::new(), discards: Vec::new(), builtins: HashSet::new(), resume_ctx: Vec::new(), @@ -498,19 +513,32 @@ impl Checker { /// Instantiate an effect at an effect-row entry's declared type arguments /// (`!State`), resolving each argument against the enclosing - /// function's type parameters; missing arguments become fresh variables. + /// function's type parameters. An omitted argument list is inferred; a + /// written list must supply exactly the declared number of arguments. /// Implements [EFFECTS-GENERIC-ROWS]. fn effect_row_scope( &mut self, row: &EffectRef, fn_typarams: &HashMap, + position: Option, ) -> Option { let info = self.effects.get(&row.name)?.clone(); + if !row.type_args.is_empty() && row.type_args.len() != info.type_params.len() { + self.errors.push( + TypeError::new(format!( + "effect `{}` takes {} type argument(s), got {}", + row.name, + info.type_params.len(), + row.type_args.len() + )) + .with_pos(position), + ); + } let mut pmap = HashMap::new(); let mut args = Vec::new(); for (i, p) in info.type_params.iter().enumerate() { let t = match row.type_args.get(i) { - Some(te) => type_expr_to_type(te, fn_typarams), + Some(te) => self.written_type_argument(te, fn_typarams, position), None => self.ctx.fresh(), }; args.push(t.clone()); @@ -627,12 +655,12 @@ impl Checker { let params: Vec = parameters .iter() .map(|p| match &p.ty { - Some(te) => type_expr_to_type(te, &typarams), + Some(te) => self.annotation_type(te, &typarams, te.position), None => self.ctx.fresh(), }) .collect(); let ret = match return_type { - Some(te) => type_expr_to_type(te, &typarams), + Some(te) => self.annotation_type(te, &typarams, te.position), None => self.ctx.fresh(), }; let ordered = type_params @@ -710,7 +738,7 @@ impl Checker { let typarams = self.fn_typarams.get(name).cloned().unwrap_or_default(); let scopes: Vec<_> = effects .iter() - .filter_map(|r| self.effect_row_scope(r, &typarams)) + .filter_map(|r| self.effect_row_scope(r, &typarams, pos)) .collect(); let pushed = scopes.len(); self.handler_scopes.extend(scopes); @@ -744,6 +772,9 @@ impl Checker { } } } + let _ = self + .scheme_obligations + .insert(format!("fn {name}"), scheme.obligations.clone()); env.insert(name, scheme); env.declare_type_params(name, declared); } @@ -757,10 +788,12 @@ impl Checker { /// report the wrapper itself, which is not an error, so the obligation /// MOVES into the scheme. fn generalize_with_obligations(&mut self, env: &TypeEnv, ty: &Type) -> Scheme { + self.resolve_field_uses(); let mut scheme = generalize(&mut self.ctx, env, ty); if scheme.vars.is_empty() { return scheme; } + self.generalize_connected_obligations(env, &mut scheme.vars); let (deferred, kept) = self.split_obligations(&scheme.vars); // Quantifying a variable that still carries a pending arithmetic // overload would hand every call site its own fresh copy, so no use @@ -774,6 +807,27 @@ impl Checker { scheme } + /// Field relations can mention callback variables absent from the visible + /// function signature. Quantify their entire connected component together. + fn generalize_connected_obligations(&mut self, env: &TypeEnv, vars: &mut Vec) { + let external = env.free_vars(&mut self.ctx); + let mut connected: BTreeSet<_> = vars.iter().copied().collect(); + loop { + let before = connected.len(); + for (_, ty) in &self.builtin_uses { + let mut free = BTreeSet::new(); + self.ctx.free_vars(ty, &mut free); + if !free.is_disjoint(&connected) { + connected.extend(free.difference(&external)); + } + } + if connected.len() == before { + *vars = connected.into_iter().collect(); + return; + } + } + } + /// Every type variable a pending arithmetic overload rests on. fn arith_operand_vars(&mut self, obligations: &[(String, Type)]) -> BTreeSet { let mut vars = BTreeSet::new(); @@ -838,8 +892,14 @@ impl Checker { self.discards.push(Discard::explicit(value_ty.clone(), pos)); } let binding_ty = if let Some(te) = ty { - let annotated = type_expr_to_type(te, &HashMap::new()); - self.unify_or_err(&annotated, &value_ty, &format!("let `{name}`"), pos); + let binder = self.current_fn_typarams.clone(); + let annotated = self.annotation_type(te, &binder, te.position.or(pos)); + self.unify_or_err( + &annotated, + &value_ty, + &format!("let `{}`", annotation_name(name)), + pos, + ); annotated } else { value_ty.clone() @@ -860,6 +920,9 @@ impl Checker { let mut scheme = self.generalize_with_obligations(env, &binding_ty); let pinned = self.stateful_handle_vars(&binding_ty); scheme.vars.retain(|v| !pinned.contains(v)); + let _ = self + .scheme_obligations + .insert(format!("let {pos:?} {name}"), scheme.obligations.clone()); if mutable { env.insert_mutable(name, scheme); } else { @@ -1009,6 +1072,7 @@ impl Checker { self.defer_arith = false; for _ in 0..self.builtin_uses.len().saturating_add(1) { let before = self.ctx.bound_count(); + self.resolve_field_uses(); let uses = self.builtin_uses.clone(); for (name, ty) in &uses { self.resolve_deferred_arith(name, ty); @@ -1088,10 +1152,32 @@ pub fn check_program_exports(program: &Program, exports: &[&str]) -> Vec crate::info::ProgramTypes { - use crate::info::{CtorLayout, ProgramTypes}; - let mut checker = checked_program(program); - let call_bindings = - crate::applications::collect(program, &checker.instantiations, &mut checker.ctx); + publish_program(program, checked_program(program), true) +} + +/// Diagnostics need one checked solve and no backend call elaboration. +pub(crate) fn infer_checked( + program: &Program, +) -> Result> { + let checker = checked_program(program); + if checker.errors.is_empty() { + Ok(publish_program(program, checker, false)) + } else { + Err(checker.errors) + } +} + +fn publish_program( + program: &Program, + mut checker: Checker, + applications: bool, +) -> crate::info::ProgramTypes { + use crate::info::ProgramTypes; + let call_bindings = if applications { + crate::applications::collect(program, &checker.instantiations, &mut checker.ctx) + } else { + HashMap::new() + }; let functions = checker .fn_sigs @@ -1102,30 +1188,7 @@ pub fn infer_program(program: &Program) -> crate::info::ProgramTypes { (name.clone(), (rp, rr)) }) .collect(); - let ctors = checker - .ctors - .iter() - .map(|(name, info)| { - // A declared type parameter resolves to a type variable — the - // backend lowers a variable to its uniform boxed representation, - // which is exactly the generic-payload rule. - let pmap = erased_type_params(&info.type_params); - let fields = info - .fields - .iter() - .map(|(f, written)| (f.clone(), type_name_to_type(written, &pmap))) - .collect(); - ( - name.clone(), - CtorLayout { - owner: info.owner.clone(), - owner_is_record: info.owner_is_record, - type_params: info.type_params.clone(), - fields, - }, - ) - }) - .collect(); + let ctors = publish_ctors(&checker); let unions = checker.union_variants.clone(); // The erased view of every effect: each declared type parameter resolves // to a type variable, which the backend lowers to its uniform boxed @@ -1173,6 +1236,8 @@ pub fn infer_program(program: &Program) -> crate::info::ProgramTypes { ((pos.line, pos.column), site) })); ProgramTypes { + obligations: publish_obligations(&mut checker), + methods: crate::methods::collect(program, &checker.methods), functions, ctors, unions, @@ -1212,6 +1277,49 @@ pub fn infer_program(program: &Program) -> crate::info::ProgramTypes { } } +/// Publish constructor fields using the common erased binder numbering. +fn publish_obligations(checker: &mut Checker) -> HashMap> { + checker + .scheme_obligations + .iter() + .map(|(owner, obligations)| { + let resolved = obligations + .iter() + .map(|(name, ty)| (name.clone(), checker.ctx.apply(ty))) + .collect(); + (owner.clone(), resolved) + }) + .collect() +} + +fn publish_ctors(checker: &Checker) -> HashMap { + use crate::info::CtorLayout; + checker + .ctors + .iter() + .map(|(name, info)| { + // A declared type parameter resolves to a type variable — the + // backend lowers a variable to its uniform boxed representation, + // which is exactly the generic-payload rule. + let pmap = erased_type_params(&info.type_params); + let fields = info + .fields + .iter() + .map(|(f, written)| (f.clone(), type_name_to_type(written, &pmap))) + .collect(); + ( + name.clone(), + CtorLayout { + owner: info.owner.clone(), + owner_is_record: info.owner_is_record, + type_params: info.type_params.clone(), + fields, + }, + ) + }) + .collect() +} + /// Collect declarations and type-check a program before either caller consumes /// diagnostics or publishes inferred backend metadata. fn checked_program(program: &Program) -> Checker { @@ -1225,6 +1333,7 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker checker.check(program, &mut env); checker.resolve_deferred_arithmetic(); loop { + checker.resolve_field_uses(); let instances = effect_instances(&mut checker); let errors = crate::effect_rows::check(program, &instances, exports); if !refine_handler_arguments(&mut checker, &instances) { @@ -1238,8 +1347,8 @@ fn checked_program_with_exports(program: &Program, exports: &[&str]) -> Checker checker } -/// Publish the current inference solution for the closed-program effect proof. -fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { +/// Compose call substitutions through aliases before specializing effects. +fn resolved_instantiations(checker: &mut Checker) -> HashMap> { let substitutions: HashMap<_, HashMap<_, _>> = checker .instantiations .iter() @@ -1253,7 +1362,7 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { ) }) .collect(); - let substitutions: HashMap<_, _> = substitutions + substitutions .iter() .map(|(site, bindings)| { ( @@ -1261,8 +1370,12 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { crate::applications::expanded(bindings, &substitutions), ) }) - .collect(); - let resolved_arguments: Vec> = checker + .collect() +} + +/// Preserve open as well as closed argument types for handler refinement. +fn resolved_effect_arguments(checker: &mut Checker) -> Vec> { + checker .perform_tys .clone() .into_iter() @@ -1271,7 +1384,13 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { .map(|arg| checker.ctx.apply(arg)) .collect::>() }) - .collect(); + .collect() +} + +/// Publish the current inference solution for the closed-program effect proof. +fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { + let substitutions = resolved_instantiations(checker); + let resolved_arguments = resolved_effect_arguments(checker); let argument_types = resolved_arguments .iter() .cloned() @@ -1326,6 +1445,7 @@ fn effect_instances(checker: &mut Checker) -> crate::effect_rows::Instances { } } crate::effect_rows::Instances { + methods: checker.methods.clone(), performs, handlers: dedupe_sites(handler_tys.into_iter().map(|(position, arguments, _)| { ( diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index 5eb27168..37cd1764 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -20,6 +20,7 @@ type HandlerCandidates = HashMap<(u32, u32), BTreeSet>>; #[derive(Default)] pub(crate) struct Instances { + pub(crate) methods: crate::methods::Targets, /// A source position can identify more than one interpolation fragment. /// Preserve every independently inferred candidate instead of letting the /// final fragment overwrite the others. @@ -60,6 +61,7 @@ struct ParameterUse { level: usize, index: usize, projection: Vec, + arguments: CallArguments, excluded: Requirements, } @@ -69,12 +71,34 @@ struct ParameterUse { #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] enum Projection { Field(String), + Method(Box), + Returned(Box), Element, SuccessValue, FiberValue, } -#[derive(Clone, Debug, Default, Eq, PartialEq)] +/// A method on a symbolic receiver cannot select its UFCS fallback until the +/// receiver is substituted. The fallback is a zero-argument closure so its +/// effects and returned value keep the same lexical scope as the field call. +#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] +struct MethodProjection { + field: String, + arguments: Vec>, + named: Vec<(String, Option)>, + fallback: Value, +} + +/// Arguments belong to the caller until a symbolic callee is substituted. +/// Keep their provenance so a callback returning an argument or captured value +/// resolves to that value, rather than to the callback itself. +#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] +struct CallArguments { + positional: Vec>, + named: Vec<(String, Option)>, +} + +#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] struct Summary { required: Requirements, parameter_uses: BTreeSet, @@ -137,13 +161,33 @@ impl Summary { } fn widen(&mut self) { + self.widen_at(0); + } + + fn widen_at(&mut self, depth: usize) { let before = self.parameter_uses.len(); self.parameter_uses.retain(|use_| { - use_.level < MAX_PROVENANCE_DEPTH && use_.projection.len() < MAX_PROVENANCE_DEPTH + use_.level < MAX_PROVENANCE_DEPTH + && use_.projection.len() < MAX_PROVENANCE_DEPTH + && (depth < MAX_PROVENANCE_DEPTH + || (use_.arguments.positional.is_empty() + && use_.arguments.named.is_empty() + && !use_.projection.iter().any(|part| { + matches!(part, Projection::Method(_) | Projection::Returned(_)) + }))) }); if self.parameter_uses.len() != before { self.unresolved_dynamic_call = true; } + self.parameter_uses = std::mem::take(&mut self.parameter_uses) + .into_iter() + .map(|mut use_| { + map_parameter_use_values(&mut use_, |value| { + *value = widen_value(value.clone(), depth + 1); + }); + use_ + }) + .collect(); } } @@ -296,14 +340,14 @@ fn qualify(scope: &[String], name: &str) -> String { } } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] struct KnownCallable { parameters: Vec, summary: Summary, returned: Option>, } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] enum Callable { Known(Box), Unknown, @@ -318,9 +362,12 @@ enum Callable { /// lattice instead of an enum: a control-flow join may produce a callable in /// one arm and a record/list in another, and discarding either provenance /// would make an effect escape possible. -#[derive(Clone, Debug, Default, Eq, PartialEq)] +#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] struct Value { callable: Option, + /// `Some` proves which fields exist, even when their values have no + /// callable provenance. `None` must never justify choosing a free function. + field_names: Option>, fields: BTreeMap, element: Option>, result_payload: Option>, @@ -332,6 +379,7 @@ struct Value { impl Value { fn from_callable(callable: Callable) -> Self { Self { + field_names: matches!(callable, Callable::Known(_)).then(BTreeSet::new), callable: Some(callable), ..Self::default() } @@ -356,16 +404,24 @@ impl Value { fn channel(site: usize) -> Self { Self { channel_sites: [site].into_iter().collect(), + field_names: Some(BTreeSet::new()), ..Self::default() } } fn union(&mut self, other: Self) { + if self.field_names != other.field_names { + self.field_names = None; + } if let Some(callable) = other.callable { merge_callable(&mut self.callable, callable); } for (name, value) in other.fields { - merge_value(self.fields.entry(name).or_default(), value); + let _ = self + .fields + .entry(name) + .and_modify(|slot| slot.union(value.clone())) + .or_insert(value); } if let Some(element) = other.element { merge_boxed_value(&mut self.element, *element); @@ -386,6 +442,9 @@ struct CallableEnv { values: HashMap, shadowed: HashSet, channel_payloads: BTreeMap, + /// Results supplied by handlers active while this expression evaluates. + /// These are dynamic bindings, never captures of a newly created closure. + handler_returns: BTreeMap, } impl CallableEnv { @@ -402,6 +461,7 @@ impl CallableEnv { fn enter_lambda(&self, parameters: &[String]) -> Self { let mut env = self.clone(); + env.handler_returns.clear(); for value in env.values.values_mut() { shift_value_levels(value, 1, 0); } @@ -516,6 +576,9 @@ impl Analyzer<'_> { reason = "the exhaustive AST effect fold is clearest as one variant-complete match" )] fn expression(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Summary { + if let Some(parts) = crate::methods::parts(expression) { + return self.method_call(expression, &parts, scope, env); + } match expression { Expr::Integer(_) | Expr::Float(_) @@ -656,7 +719,8 @@ impl Analyzer<'_> { &self.instances.handlers, "handler", ); - let body_summary = self.expression(body, scope, env); + let local = self.handler_body_env(effect, arms, body, *position, scope, env); + let body_summary = self.expression(body, scope, &local); if let Some(position) = position { let candidates = body_summary.required.iter().filter(|requirement| { requirement.effect == *effect && handled.contains(&requirement.operation) @@ -690,7 +754,19 @@ impl Analyzer<'_> { let mut out = self.expression(function, scope, env); out.union(self.expressions(arguments, scope, env)); out.union(self.named_expressions(named_arguments, scope, env)); + out.union(self.call_effects(function, arguments, named_arguments, scope, env)); + out + } + fn call_effects( + &self, + function: &Expr, + arguments: &[Expr], + named_arguments: &[NamedArgument], + scope: &[String], + env: &CallableEnv, + ) -> Summary { + let mut out = Summary::default(); if let Some(callee) = self.callable(function, scope, env) { out.union(self.invoke(callee, arguments, named_arguments, scope, env)); } else if !statically_named_callee(function, env, self.index) { @@ -699,7 +775,7 @@ impl Analyzer<'_> { // provenance, fail closed instead of assuming the call is pure. out.unresolved_dynamic_call = true; } - if let Some(name) = expression_name(function) { + if let Some(name) = self.builtin_callee(function, scope, env) { if iterator_consumer(name) { if let Some(iterator) = arguments .first() @@ -719,6 +795,164 @@ impl Analyzer<'_> { out } + fn method_call( + &self, + expression: &Expr, + parts: &crate::methods::Parts<'_>, + scope: &[String], + env: &CallableEnv, + ) -> Summary { + let site = std::ptr::from_ref(expression).addr(); + let mut out = match self.instances.methods.get(&site) { + Some(crate::methods::Target::Field(field)) => { + let mut out = self.expression(parts.target, scope, env); + out.union(self.expressions(parts.arguments, scope, env)); + out.union(self.named_expressions(parts.named, scope, env)); + let callee = self + .value(parts.target, scope, env) + .and_then(|value| project_field(value, field)) + .and_then(|value| value.callable); + if let Some(callee) = callee { + out.union(self.invoke(callee, parts.arguments, parts.named, scope, env)); + } else { + out.unresolved_dynamic_call = true; + } + out + } + Some(crate::methods::Target::Deferred(field)) => { + let mut out = self.expression(parts.target, scope, env); + out.union(self.expressions(parts.arguments, scope, env)); + out.union(self.named_expressions(parts.named, scope, env)); + let callee = self + .deferred_method(parts, field, scope, env) + .and_then(|value| value.callable); + if let Some(callee) = callee { + out.union(self.invoke_with_values(callee, &[])); + } else { + out.unresolved_dynamic_call = true; + } + out + } + Some(crate::methods::Target::Function) | None => self.call( + &Expr::Identifier(parts.method.to_owned()), + &receiver_first(parts.target, parts.arguments), + parts.named, + scope, + env, + ), + }; + if let Some(bindings) = self.instances.instantiations.get(&site) { + specialize_summary(&mut out, bindings); + } + out + } + + fn deferred_method( + &self, + parts: &crate::methods::Parts<'_>, + field: &str, + scope: &[String], + env: &CallableEnv, + ) -> Option { + let function = Expr::Identifier(parts.method.to_owned()); + let arguments = receiver_first(parts.target, parts.arguments); + let fallback = method_thunk( + self.call_effects(&function, &arguments, parts.named, scope, env), + self.call_value(&function, &arguments, parts.named, scope, env), + ); + let method = MethodProjection { + field: field.to_owned(), + arguments: parts + .arguments + .iter() + .map(|argument| self.value(argument, scope, env)) + .collect(), + named: parts + .named + .iter() + .map(|argument| { + ( + argument.name.clone(), + self.value(&argument.value, scope, env), + ) + }) + .collect(), + fallback, + }; + self.value(parts.target, scope, env) + .and_then(|value| self.project_method(value, method)) + } + + fn project_method(&self, mut receiver: Value, method: MethodProjection) -> Option { + let mut projected = if let Some(value) = receiver.fields.remove(&method.field) { + value.callable.map(|callee| { + let parameters = match &callee { + Callable::Known(known) => known.parameters.as_slice(), + _ => &[], + }; + let arguments = ordered_values(parameters, &method.arguments, &method.named); + method_thunk( + self.invoke_with_values(callee.clone(), &arguments), + self.called_value_with_values(callee, &arguments), + ) + }) + } else if receiver + .field_names + .as_ref() + .is_some_and(|fields| !fields.contains(&method.field)) + { + Some(method.fallback.clone()) + } else { + None + }; + if receiver.field_names.is_none() { + project_callable( + receiver.callable, + Projection::Method(Box::new(method)), + &mut projected, + ); + } + projected + } + + fn project_path(&self, mut value: Value, path: &[Projection]) -> Option { + for projection in path { + value = match projection { + Projection::Field(field) => project_field(value, field), + Projection::Method(method) => self.project_method(value, *method.clone()), + Projection::Returned(arguments) => { + self.project_call_return(value, *arguments.clone()) + } + Projection::Element => project_element(value), + Projection::SuccessValue => project_success_value(value), + Projection::FiberValue => project_fiber_value(value), + }?; + } + Some(value) + } + + fn project_returned(&self, value: Value) -> Option { + self.project_call_return(value, CallArguments::default()) + } + + fn project_call_return(&self, mut value: Value, arguments: CallArguments) -> Option { + if let Some(Callable::Known(known)) = &mut value.callable { + let values = ordered_values(&known.parameters, &arguments.positional, &arguments.named); + return known + .returned + .take() + .map(|returned| self.substitute_value_at(*returned, 0, &values)) + .or_else(|| Some(Value::default())); + } + let mut projected = None; + project_callable( + value.callable, + Projection::Returned(Box::new(arguments)), + &mut projected, + ); + projected + } + fn invoke( &self, callee: Callable, @@ -727,18 +961,26 @@ impl Analyzer<'_> { scope: &[String], env: &CallableEnv, ) -> Summary { - let parameters: &[String] = match &callee { - Callable::Known(known) => &known.parameters, - Callable::Parameter { .. } | Callable::Unknown => &[], - }; - let values = self.argument_values(parameters, arguments, named_arguments, scope, env); - self.invoke_with_values(callee, &values) + let arguments = self.call_arguments(arguments, named_arguments, scope, env); + self.invoke_with_arguments(callee, arguments) } fn invoke_with_values(&self, callee: Callable, arguments: &[Option]) -> Summary { + self.invoke_with_arguments( + callee, + CallArguments { + positional: arguments.to_vec(), + named: Vec::new(), + }, + ) + } + + fn invoke_with_arguments(&self, callee: Callable, arguments: CallArguments) -> Summary { match callee { Callable::Known(known) => { - self.substitute_summary_at(known.summary.clone(), 0, arguments) + let values = + ordered_values(&known.parameters, &arguments.positional, &arguments.named); + self.substitute_summary_at(known.summary.clone(), 0, &values) } Callable::Unknown => Summary { unresolved_dynamic_call: true, @@ -754,6 +996,7 @@ impl Analyzer<'_> { level, index, projection, + arguments, excluded: Requirements::new(), }] .into_iter() @@ -795,20 +1038,43 @@ impl Analyzer<'_> { scope: &[String], env: &CallableEnv, ) -> Option { - if let Some(name) = expression_name(function) { + if let Some(name) = self.builtin_callee(function, scope, env) { if let Some(value) = self.builtin_call_value(name, arguments, scope, env) { return Some(value); } } - // A PARTIAL application of a parameter is still that parameter being - // invoked: `f a b` curries to `Call(Call(f, [a]), [b])` - // ([FLAVOR-ML-CURRY]), and the effect requirement belongs to `f` - // whichever spelling reaches here. Dropping the callable at the inner - // call left the outer one with a `Call` head, which no rule can name, - // so the whole entry was reported unprovable. + // Preserve each application in a curried spine: its result can be a + // returned closure or aggregate with different effects from its maker. let resolved = self.callable(function, scope, env); + self.called_value(resolved, arguments, named_arguments, scope, env) + } + + /// Builtin behavior belongs to the resolved binding, not its spelling. + /// Local values and user functions may shadow callable builtin names. + fn builtin_callee<'b>( + &self, + function: &'b Expr, + scope: &[String], + env: &CallableEnv, + ) -> Option<&'b str> { + let name = expression_name(function)?; + (!env.shadowed.contains(name) + && !env.values.contains_key(name) + && self.index.resolve(scope, name).is_none()) + .then_some(name) + } + + fn called_value( + &self, + resolved: Option, + arguments: &[Expr], + named_arguments: &[NamedArgument], + scope: &[String], + env: &CallableEnv, + ) -> Option { if let Some(parameter @ Callable::Parameter { .. }) = resolved { - return Some(Value::from_callable(parameter)); + let arguments = self.call_arguments(arguments, named_arguments, scope, env); + return self.project_call_return(Value::from_callable(parameter), arguments); } let Some(Callable::Known(known)) = resolved else { // The RESULT of a call we cannot resolve is not thereby a callable. @@ -822,11 +1088,46 @@ impl Analyzer<'_> { }; let arguments = self.argument_values(&known.parameters, arguments, named_arguments, scope, env); + self.called_value_with_values(Callable::Known(known), &arguments) + } + + fn call_arguments( + &self, + arguments: &[Expr], + named: &[NamedArgument], + scope: &[String], + env: &CallableEnv, + ) -> CallArguments { + CallArguments { + positional: arguments + .iter() + .map(|argument| self.value(argument, scope, env)) + .collect(), + named: named + .iter() + .map(|argument| { + ( + argument.name.clone(), + self.value(&argument.value, scope, env), + ) + }) + .collect(), + } + } + + fn called_value_with_values( + &self, + callee: Callable, + arguments: &[Option], + ) -> Option { + let Callable::Known(known) = callee else { + return Some(Value::unknown_callable()); + }; known .returned .as_deref() .cloned() - .map(|returned| self.substitute_value_at(returned, 0, &arguments)) + .map(|returned| self.substitute_value_at(returned, 0, arguments)) // A known callee with no recorded return provenance says nothing // about whether its RESULT is callable — most such results are // ordinary data, and `returned` is also what the depth cutoff drops @@ -853,10 +1154,14 @@ impl Analyzer<'_> { }; let aggregate = |element: Option| Value { element: element.map(Box::new), + field_names: Some(BTreeSet::new()), ..Value::default() }; Some(match name { - "range" | "List" | "Map" => Value::default(), + "range" | "List" | "Map" => Value { + field_names: Some(BTreeSet::new()), + ..Value::default() + }, "map" | "filter" => self.lazy_iterator_value(name, arguments, scope, env), "mapList" | "filterList" => { let mut value = self.lazy_iterator_value(name, arguments, scope, env); @@ -899,7 +1204,7 @@ impl Analyzer<'_> { aggregate(merged) } "mapValues" => aggregate(element(0)), - _ => return None, + _ => return builtin_return_shape(name), }) } @@ -938,6 +1243,7 @@ impl Analyzer<'_> { Value { element: element.map(Box::new), deferred, + field_names: Some(BTreeSet::new()), ..Value::default() } } @@ -1014,7 +1320,40 @@ impl Analyzer<'_> { reason = "value provenance mirrors the exhaustive expression fold" )] fn raw_value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { + if let Some(parts) = crate::methods::parts(expression) { + return match self + .instances + .methods + .get(&std::ptr::from_ref(expression).addr()) + { + Some(crate::methods::Target::Field(field)) => { + let callee = self + .value(parts.target, scope, env) + .and_then(|value| project_field(value, field)) + .and_then(|value| value.callable); + self.called_value(callee, parts.arguments, parts.named, scope, env) + } + Some(crate::methods::Target::Deferred(field)) => self + .deferred_method(&parts, field, scope, env) + .and_then(|value| self.project_returned(value)), + Some(crate::methods::Target::Function) | None => self.call_value( + &Expr::Identifier(parts.method.to_owned()), + &receiver_first(parts.target, parts.arguments), + parts.named, + scope, + env, + ), + }; + } match expression { + Expr::Integer(_) + | Expr::Float(_) + | Expr::Str(_) + | Expr::Bool(_) + | Expr::InterpolatedStr(_) => Some(Value { + field_names: Some(BTreeSet::new()), + ..Value::default() + }), Expr::TypeApply { function, .. } => self.value(function, scope, env), Expr::Identifier(name) => { if let Some(value) = env.values.get(name) { @@ -1056,8 +1395,9 @@ impl Analyzer<'_> { merge_optional_value(&mut element, value); } } - element.map(|element| Value { - element: Some(Box::new(element)), + Some(Value { + element: element.map(Box::new), + field_names: Some(BTreeSet::new()), ..Value::default() }) } @@ -1068,8 +1408,9 @@ impl Analyzer<'_> { merge_optional_value(&mut element, value); } } - element.map(|element| Value { - element: Some(Box::new(element)), + Some(Value { + element: element.map(Box::new), + field_names: Some(BTreeSet::new()), ..Value::default() }) } @@ -1091,7 +1432,7 @@ impl Analyzer<'_> { // Ordered after the shadowed-constructor guard above: a shadowed // name is a record update, not a fresh record. Expr::Object(fields) | Expr::TypeConstructor { fields, .. } => { - self.record_value(fields, scope, env) + Some(self.record_value(fields, scope, env)) } Expr::Update { record, fields } => { let mut updated = self @@ -1115,6 +1456,7 @@ impl Analyzer<'_> { ..Value::default() }), Expr::Spawn(value) => Some(Value { + field_names: Some(BTreeSet::new()), fiber_payload: Some(Box::new( self.value(value, scope, env) .unwrap_or_else(Value::unknown_callable), @@ -1158,6 +1500,29 @@ impl Analyzer<'_> { env, ), Expr::Pipe { left, right } => self.pipe_value(left, right, scope, env), + Expr::Perform { + effect, + operation, + position, + .. + } => { + let mut merged = None; + for arguments in self.perform_instance_arguments(effect, *position) { + let requirement = Requirement { + effect: effect.clone(), + operation: operation.clone(), + arguments, + }; + if let Some(value) = env.handler_returns.get(&requirement) { + merge_optional_value(&mut merged, value.clone()); + } else { + // A missing candidate cannot be supplied by a different + // generic instance of this operation. + merge_optional_value(&mut merged, Value::unknown_callable()); + } + } + merged + } Expr::Match { value, arms } => { let matched = self.value(value, scope, env); let mut merged = None; @@ -1173,9 +1538,14 @@ impl Analyzer<'_> { // A handler governs evaluation of its body, not later use of a // value produced by that body or one of its operation arms. Expr::Handler { - effect, arms, body, .. + effect, + arms, + body, + position, + .. } => { - let mut merged = self.value(body, scope, env); + let local = self.handler_body_env(effect, arms, body, *position, scope, env); + let mut merged = self.value(body, scope, &local); for arm in arms { let local = self.handler_arm_env(effect, arm, body, scope, env); if let Some(value) = self.value(&arm.body, scope, &local) { @@ -1205,16 +1575,15 @@ impl Analyzer<'_> { } } - /// Record-shaped literals — an object literal and a type constructor — - /// carry the same value information: only the fields whose value is itself - /// inferable. A record with nothing inferable tells the pass nothing, so it - /// yields `None` rather than an empty record that would mask a callable. + /// Keep the complete field set independently of callable provenance: an + /// opaque field is not evidence that a same-named free function should run. fn record_value( &self, fields: &[FieldAssignment], scope: &[String], env: &CallableEnv, - ) -> Option { + ) -> Value { + let field_names = Some(fields.iter().map(|field| field.name.clone()).collect()); let fields: BTreeMap<_, _> = fields .iter() .filter_map(|field| { @@ -1222,10 +1591,11 @@ impl Analyzer<'_> { .map(|value| (field.name.clone(), value)) }) .collect(); - (!fields.is_empty()).then_some(Value { + Value { + field_names, fields, ..Value::default() - }) + } } fn function_value(&self, id: usize) -> Value { @@ -1318,16 +1688,19 @@ impl Analyzer<'_> { ) -> Summary { let uses = std::mem::take(&mut summary.parameter_uses); for mut use_ in uses { + map_parameter_use_values(&mut use_, |value| { + *value = self.substitute_value_at(value.clone(), target_level, arguments); + }); if use_.level == target_level { let callback = arguments .get(use_.index) .and_then(Option::as_ref) .cloned() - .and_then(|value| project_path(value, &use_.projection)) + .and_then(|value| self.project_path(value, &use_.projection)) .and_then(|value| value.callable); if let Some(callback) = callback { let mut invoked = self - .invoke_with_values(callback, &[]) + .invoke_with_arguments(callback, use_.arguments) .excluding(&use_.excluded); shift_summary_levels(&mut invoked, target_level); summary.union(invoked); @@ -1377,10 +1750,15 @@ impl Analyzer<'_> { self.substitute_payload_at(&mut value.result_payload, target_level, arguments); self.substitute_payload_at(&mut value.fiber_payload, target_level, arguments); value.deferred = self.substitute_summary_at(value.deferred, target_level, arguments); + if let Some(Callable::Parameter { projection, .. }) = &mut value.callable { + map_projection_values(projection, |value| { + *value = self.substitute_value_at(value.clone(), target_level, arguments); + }); + } if let Some(callable) = value.callable.take() { match callable { Callable::Parameter { - mut level, + level, index, projection, } if level == target_level => { @@ -1388,17 +1766,22 @@ impl Analyzer<'_> { .get(index) .and_then(Option::as_ref) .cloned() - .and_then(|argument| project_path(argument, &projection)) + .and_then(|argument| self.project_path(argument, &projection)) { shift_value_levels(&mut replacement, target_level, 0); + value.field_names.clone_from(&replacement.field_names); value.union(replacement); - } else { - level = target_level.saturating_sub(1); + } else if index >= arguments.len() { + // Only an absent argument keeps the original binder. + // A supplied opaque value or failed projection must + // never be resolved through an unrelated caller slot. value.callable = Some(Callable::Parameter { level, index, projection, }); + } else { + value.callable = Some(Callable::Unknown); } } Callable::Parameter { @@ -1477,6 +1860,37 @@ impl Analyzer<'_> { local } + fn handler_body_env( + &self, + effect: &str, + arms: &[HandlerArm], + body: &Expr, + position: Option, + scope: &[String], + env: &CallableEnv, + ) -> CallableEnv { + let arguments = + self.instance_arguments(effect, position, &self.instances.handlers, "handler"); + let mut local = env.clone(); + for arm in arms { + // Arms execute outside this handler, so resolve their returned + // values using only the outer handler environment. + let mut arm_env = self.handler_arm_env(effect, arm, body, scope, env); + let value = self + .returned_value(&arm.body, scope, &mut arm_env) + .unwrap_or_else(Value::unknown_callable); + let _ = local.handler_returns.insert( + Requirement { + effect: effect.to_owned(), + operation: arm.operation.clone(), + arguments: arguments.clone(), + }, + value, + ); + } + local + } + #[expect( clippy::too_many_arguments, reason = "operation payload provenance needs the lexical effect, arm, and value environment" @@ -1709,16 +2123,112 @@ fn project_callable(callable: Option, next: Projection, projected: &mu merge_optional_value(projected, Value::from_callable(callable)); } -fn project_path(mut value: Value, path: &[Projection]) -> Option { - for projection in path { - value = match projection { - Projection::Field(field) => project_field(value, field), - Projection::Element => project_element(value), - Projection::SuccessValue => project_success_value(value), - Projection::FiberValue => project_fiber_value(value), - }?; +fn method_thunk(mut summary: Summary, mut returned: Option) -> Value { + shift_summary_levels(&mut summary, 1); + if let Some(returned) = &mut returned { + shift_value_levels(returned, 1, 0); + } + Value::from_callable(Callable::Known(Box::new(KnownCallable { + parameters: Vec::new(), + summary, + returned: returned.map(Box::new), + }))) +} + +/// Built-in signatures can prove a primitive result has no fields without +/// inventing callable provenance for an otherwise opaque result. +fn builtin_return_shape(name: &str) -> Option { + // Effect summaries revisit calls during fixed-point inference and warning + // comparisons. Their immutable builtin signatures need one shared table. + static BUILTINS: std::sync::LazyLock = + std::sync::LazyLock::new(crate::builtins::base_env); + let crate::ty::Type::Fun { ret, .. } = &BUILTINS.get(name)?.ty else { + return None; + }; + value_shape(ret) +} + +fn value_shape(ty: &crate::ty::Type) -> Option { + use crate::ty::{names, Type}; + match ty { + Type::Con { name, args } if name == names::RESULT => Some(Value { + result_payload: args.first().and_then(value_shape).map(Box::new), + ..Value::default() + }), + Type::Con { name, .. } + if matches!( + name.as_str(), + names::INT + | names::FLOAT + | names::STRING + | names::BOOL + | names::UNIT + | names::LIST + | names::MAP + | names::ITERATOR + | names::FIBER + | names::CHANNEL + | names::PTR + | names::GPU_BUFFER + ) => + { + Some(Value { + field_names: Some(BTreeSet::new()), + ..Value::default() + }) + } + _ => None, + } +} + +fn map_projection_values(projection: &mut [Projection], mut visit: impl FnMut(&mut Value)) { + for part in projection { + let (positional, named) = match part { + Projection::Method(method) => { + visit(&mut method.fallback); + (&mut method.arguments, &mut method.named) + } + Projection::Returned(arguments) => (&mut arguments.positional, &mut arguments.named), + _ => continue, + }; + for value in positional + .iter_mut() + .chain(named.iter_mut().map(|(_, value)| value)) + .flatten() + { + visit(value); + } + } +} + +fn map_parameter_use_values(use_: &mut ParameterUse, mut visit: impl FnMut(&mut Value)) { + map_projection_values(&mut use_.projection, &mut visit); + for value in use_ + .arguments + .positional + .iter_mut() + .chain(use_.arguments.named.iter_mut().map(|(_, value)| value)) + .flatten() + { + visit(value); + } +} + +fn ordered_values( + parameters: &[String], + positional: &[Option], + named: &[(String, Option)], +) -> Vec> { + let mut values = positional.to_vec(); + values.resize(values.len().max(parameters.len()), None); + for (name, value) in named { + if let Some(index) = parameters.iter().position(|parameter| parameter == name) { + if let Some(slot) = values.get_mut(index) { + slot.clone_from(value); + } + } } - Some(value) + values } fn merge_value(slot: &mut Value, incoming: Value) { @@ -1758,13 +2268,21 @@ fn widen_value(mut value: Value, depth: usize) -> Value { // unresolvable dynamic call, and discarding `deferred.required` would // silently discharge an operation that still needs a handler. let mut deferred = value.deferred; - deferred.widen(); + deferred.widen_at(depth); let callable = match value.callable { Some(Callable::Known(mut known)) => { known.returned = None; - known.summary.widen(); + known.summary.widen_at(depth); Some(Callable::Known(known)) } + Some(Callable::Parameter { ref projection, .. }) + if projection.iter().any(|part| { + matches!(part, Projection::Method(_) | Projection::Returned(_)) + }) => + { + deferred.unresolved_dynamic_call = true; + Some(Callable::Unknown) + } // A value that was never callable must not BECOME one here. // Promoting `None` to `Unknown` would turn "this is an int" into // "this is a callable of unknown provenance", and every merge it @@ -1779,11 +2297,11 @@ fn widen_value(mut value: Value, depth: usize) -> Value { }; } - value.deferred.widen(); + value.deferred.widen_at(depth); if let Some(callable) = value.callable.take() { value.callable = Some(match callable { Callable::Known(mut known) => { - known.summary.widen(); + known.summary.widen_at(depth); known.returned = known .returned .map(|returned| Box::new(widen_value(*returned, depth + 1))); @@ -1792,8 +2310,11 @@ fn widen_value(mut value: Value, depth: usize) -> Value { Callable::Parameter { level, index, - projection, + mut projection, } if level < MAX_PROVENANCE_DEPTH && projection.len() < MAX_PROVENANCE_DEPTH => { + map_projection_values(&mut projection, |value| { + *value = widen_value(value.clone(), depth + 1); + }); Callable::Parameter { level, index, @@ -1832,6 +2353,9 @@ fn shift_summary_from(summary: &mut Summary, amount: usize, minimum_level: usize if use_.level >= minimum_level { use_.level = use_.level.saturating_add(amount); } + map_parameter_use_values(&mut use_, |value| { + shift_value_levels(value, amount, minimum_level); + }); use_ }) .collect(); @@ -1844,10 +2368,15 @@ fn shift_summary_levels(summary: &mut Summary, amount: usize) { fn shift_value_levels(value: &mut Value, amount: usize, minimum_level: usize) { if let Some(callable) = &mut value.callable { match callable { - Callable::Parameter { level, .. } => { + Callable::Parameter { + level, projection, .. + } => { if *level >= minimum_level { *level = level.saturating_add(amount); } + map_projection_values(projection, |value| { + shift_value_levels(value, amount, minimum_level); + }); } Callable::Known(known) => { shift_summary_from(&mut known.summary, amount, minimum_level + 1); @@ -1890,6 +2419,7 @@ fn callable_summary(callable: &Callable) -> Summary { level: *level, index: *index, projection: projection.clone(), + arguments: CallArguments::default(), excluded: Requirements::new(), }] .into_iter() @@ -2106,24 +2636,38 @@ fn converge( /// the next sweep can re-derive each verdict from converged provenance. fn clear_verdicts(rows: &mut [Summary], returns: &mut [Option]) { for row in rows.iter_mut() { - row.unresolved_dynamic_call = false; + clear_summary_verdicts(row); } for returned in returns.iter_mut().flatten() { clear_value_verdicts(returned); } } +fn clear_summary_verdicts(summary: &mut Summary) { + summary.unresolved_dynamic_call = false; + summary.parameter_uses = std::mem::take(&mut summary.parameter_uses) + .into_iter() + .map(|mut use_| { + map_parameter_use_values(&mut use_, clear_value_verdicts); + use_ + }) + .collect(); +} + fn clear_value_verdicts(value: &mut Value) { - value.deferred.unresolved_dynamic_call = false; + clear_summary_verdicts(&mut value.deferred); // `Callable::Unknown` is deliberately left in place: it is the SHAPE that // makes an invocation unresolvable, so the next sweep raises the verdict // again wherever the callable is actually called. if let Some(Callable::Known(known)) = &mut value.callable { - known.summary.unresolved_dynamic_call = false; + clear_summary_verdicts(&mut known.summary); if let Some(returned) = &mut known.returned { clear_value_verdicts(returned); } } + if let Some(Callable::Parameter { projection, .. }) = &mut value.callable { + map_projection_values(projection, clear_value_verdicts); + } for nested in value.fields.values_mut() { clear_value_verdicts(nested); } @@ -2177,6 +2721,9 @@ fn specialize_summary(summary: &mut Summary, bindings: &HashMap) .into_iter() .map(|mut use_| { specialize_requirements(&mut use_.excluded, bindings); + map_parameter_use_values(&mut use_, |value| { + specialize_value(value, bindings); + }); use_ }) .collect(); @@ -2184,6 +2731,9 @@ fn specialize_summary(summary: &mut Summary, bindings: &HashMap) fn specialize_value(value: &mut Value, bindings: &HashMap) { specialize_summary(&mut value.deferred, bindings); + if let Some(Callable::Parameter { projection, .. }) = &mut value.callable { + map_projection_values(projection, |value| specialize_value(value, bindings)); + } if let Some(Callable::Known(known)) = &mut value.callable { specialize_summary(&mut known.summary, bindings); if let Some(returned) = &mut known.returned { diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index 7162b12b..7127cb60 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -107,6 +107,9 @@ impl TypeEnv { for scheme in self.vars.values() { let mut fv = BTreeSet::new(); ctx.free_vars(&scheme.ty, &mut fv); + for (_, obligation) in &scheme.obligations { + ctx.free_vars(obligation, &mut fv); + } for q in &scheme.vars { let _ = fv.remove(q); } @@ -177,7 +180,6 @@ pub(crate) fn subst_vars(t: &Type, map: &HashMap) -> Type { }, } } - #[cfg(test)] #[expect( clippy::indexing_slicing, diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index 0501a3ea..57814ce1 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -5,19 +5,7 @@ //! lambdas, match) do real unification. use crate::check::Checker; -use crate::convert::type_expr_to_type; - -/// Builtin types that carry no fields, so `x.field` on one can never resolve. -/// Deliberately excludes `any` (which unifies with everything, including -/// records) and every collection/generic whose element MIGHT be a record. -/// Implements [TYPE-FIELD-ACCESS-NON-RECORD]. -const FIELDLESS_TYPES: &[&str] = &[ - names::INT, - names::FLOAT, - names::STRING, - names::BOOL, - names::UNIT, -]; + use crate::env::TypeEnv; use crate::error::TypeError; use crate::ty::{names, Type}; @@ -37,6 +25,23 @@ fn generic_err() -> Type { Type::prim("Error") } +/// A bound type variable is a type, not a higher-kinded constructor. Check +/// the written form before conversion resolves that name to its variable. +fn applied_type_parameter<'a>( + ty: &'a TypeExpr, + binders: &HashMap, +) -> Option<&'a str> { + if binders.contains_key(&ty.name) && !ty.generic_params.is_empty() { + return Some(&ty.name); + } + ty.generic_params + .iter() + .chain(&ty.parameter_types) + .chain(ty.array_element.as_deref()) + .chain(ty.return_type.as_deref()) + .find_map(|child| applied_type_parameter(child, binders)) +} + impl Checker { pub(crate) fn infer_expr(&mut self, e: &Expr, env: &TypeEnv) -> Type { match e { @@ -99,15 +104,13 @@ impl Checker { function, arguments, named_arguments, - } => self.infer_call(function, arguments, named_arguments, env), + } => self.infer_call(e, function, arguments, named_arguments, env), Expr::Pipe { left, right } => self.infer_pipe(left, right, env), Expr::FieldAccess { target, field } => self.infer_field_access(target, field, env), - Expr::MethodCall { - target, - method, - arguments, - named_arguments, - } => self.infer_method_call(target, method, arguments, named_arguments, env), + Expr::MethodCall { .. } => match crate::methods::parts(e) { + Some(parts) => self.infer_method_call(e, parts, env), + None => self.ctx.fresh(), + }, Expr::Index { target, index } => self.infer_index(target, index, env), Expr::Lambda { parameters, @@ -181,55 +184,27 @@ impl Checker { } } - /// Field access yields the record field's declared type, or a fresh var when - /// the target is not a known record (split out of [`Self::infer_expr`]). + /// Field access retains a relation between the receiver and its field even + /// when the receiver is a parameter whose record is fixed at a later call. fn infer_field_access(&mut self, target: &Expr, field: &str, env: &TypeEnv) -> Type { let tt = self.infer_expr(target, env); + self.infer_record_field_type(&tt, field) + } + + pub(crate) fn infer_record_field_type(&mut self, receiver: &Type, field: &str) -> Type { // Reading a field assumes a record layout the erased word cannot // prove it has — the address-as-integer bug reached through `.field` // ([TYPE-FIELD-ACCESS-NON-RECORD], [TYPE-ANY]). - if self.reject_erased_operand(&format!("access field `{field}` on"), &tt) { + if self.reject_erased_operand(&format!("access field `{field}` on"), receiver) { return self.ctx.fresh(); } - let pruned = self.ctx.prune(&tt); - match &pruned { - Type::Record { fields, .. } => fields - .get(field) - .cloned() - .unwrap_or_else(|| self.ctx.fresh()), - other => { - if let Type::Con { name, .. } = other { - if FIELDLESS_TYPES.contains(&name.as_str()) { - self.record_field_access_on_fieldless(field, name); - } - } - if let Type::Con { name, args } = other { - if let Some(ty) = self - .ctx - .record_fields(name, args) - .and_then(|fields| fields.get(field).cloned()) - { - return ty; - } - } - self.ctx.fresh() - } - } - } - - /// Reject `x.field` where `x` is a builtin that has no fields at all. - /// - /// This arm used to fall through to a fresh variable, so the program passed - /// the checker and CODEGEN emitted invalid LLVM (`bitcast i8* 42 to - /// { i64, i64 }*`) — the "error" then surfaced from clang, naming a - /// temporary `.ll` file rather than the offending source line. Only names - /// that can NEVER be a user record are listed, and an unresolved type - /// variable is deliberately left alone: inference may still resolve it to a - /// record. Implements [TYPE-FIELD-ACCESS-NON-RECORD]. - fn record_field_access_on_fieldless(&mut self, field: &str, ty: &str) { - self.errors.push(TypeError::new(format!( - "cannot access field '{field}' on non-struct type {ty}" - ))); + let result = self.ctx.fresh(); + self.builtin_uses.push(( + crate::fields::obligation_name(field), + Type::fun(vec![receiver.clone()], result.clone()), + )); + self.resolve_field_uses(); + result } /// A channel and its sent value share one element type; the send is `Unit`. @@ -563,11 +538,15 @@ impl Checker { fn infer_call( &mut self, + site: &Expr, function: &Expr, arguments: &[Expr], named: &[NamedArgument], env: &TypeEnv, ) -> Type { + if let Some(parts) = crate::methods::parts(site) { + return self.infer_method_call(site, parts, env); + } let (fname, ft) = self.infer_callee(function, env); let args = self.ordered_arg_types(fname.as_deref(), &ft, arguments, named, env); self.apply_named_fn(fname.as_deref(), &ft, args) @@ -629,8 +608,7 @@ impl Checker { if params.len() == type_args.len() { let binder = self.current_fn_typarams.clone(); for (param, arg) in params.iter().zip(type_args) { - let written = crate::convert::type_expr_to_type(arg, &binder); - self.validate_type_argument(&written, position); + let written = self.written_type_argument(arg, &binder, position); self.push_unify(param, &written); } } else { @@ -646,6 +624,38 @@ impl Checker { (Some(name), ty) } + /// Validate written arguments before conversion can discard an invalid + /// application of an enclosing binder [TYPE-GENERICS-APPLY]. + pub(crate) fn written_type_argument( + &mut self, + argument: &osprey_ast::TypeExpr, + binder: &HashMap, + position: Option, + ) -> Type { + let written = self.annotation_type(argument, binder, position); + self.validate_type_argument(&written, position); + written + } + + /// Preserve lexical binders in annotations without accepting applications + /// that conversion would otherwise silently drop [TYPE-GENERICS-FN]. + pub(crate) fn annotation_type( + &mut self, + argument: &osprey_ast::TypeExpr, + binder: &HashMap, + position: Option, + ) -> Type { + if let Some(name) = applied_type_parameter(argument, binder) { + self.errors.push( + TypeError::new(format!( + "type parameter `{name}` cannot take type arguments" + )) + .with_pos(position), + ); + } + crate::convert::type_expr_to_type(argument, binder) + } + /// Written arguments name declared types or an enclosing binder, never a /// new nominal type inferred from a misspelled name [TYPE-GENERICS-APPLY]. fn validate_type_argument(&mut self, ty: &Type, position: Option) { @@ -672,6 +682,31 @@ impl Checker { self.errors .push(TypeError::new(format!("unknown type `{name}`")).with_pos(position)); } + let arity = self + .ctx + .variance_of(name) + .map(<[_]>::len) + .or_else(|| { + self.ctors + .values() + .find(|ctor| ctor.owner == *name) + .map(|ctor| ctor.type_params.len()) + }) + .or_else(|| { + primitive.then_some(usize::from(matches!( + name.as_str(), + names::CHANNEL | names::ITERATOR | names::GPU_BUFFER + ))) + }); + if let Some(expected) = arity.filter(|expected| *expected != args.len()) { + self.errors.push( + TypeError::new(format!( + "type `{name}` takes {expected} type argument(s), got {}", + args.len() + )) + .with_pos(position), + ); + } for arg in args { self.validate_type_argument(arg, position); } @@ -688,22 +723,174 @@ impl Checker { fn infer_method_call( &mut self, - target: &Expr, - method: &str, - arguments: &[Expr], - named: &[NamedArgument], + site: &Expr, + parts: crate::methods::Parts<'_>, env: &TypeEnv, ) -> Type { - // UFCS: `t.m(a)` is `m(t, a)`. - let ft = self.lookup_ident(method, env); - let mut args = vec![self.infer_expr(target, env)]; - for a in arguments { - args.push(self.infer_expr(a, env)); + let receiver = self.infer_expr(parts.target, env); + let field = crate::methods::field_name(parts.method); + if matches!(self.ctx.prune(&receiver), Type::Var(_)) && env.get(parts.method).is_some() { + let _ = self.methods.insert( + std::ptr::from_ref(site).addr(), + crate::methods::Target::Deferred(field.clone()), + ); + return self.infer_deferred_method(site, receiver, &field, &parts, env); + } + let known_field = match self.ctx.prune(&receiver) { + Type::Record { fields, .. } => fields.contains_key(&field), + Type::Con { name, args } => self + .ctx + .record_fields(&name, &args) + .is_some_and(|fields| fields.contains_key(&field)), + Type::Var(_) => env.get(parts.method).is_none(), + _ => false, + }; + if known_field { + let _ = self.methods.insert( + std::ptr::from_ref(site).addr(), + crate::methods::Target::Field(field.clone()), + ); + return self.infer_field_call(&receiver, &field, &parts, env); + } + if env.get(parts.method).is_some() { + let _ = self.methods.insert( + std::ptr::from_ref(site).addr(), + crate::methods::Target::Function, + ); + } + self.infer_ufcs_call(site, &receiver, &parts, env) + } + + fn infer_deferred_method( + &mut self, + site: &Expr, + receiver: Type, + field: &str, + parts: &crate::methods::Parts<'_>, + env: &TypeEnv, + ) -> Type { + let Some(fallback) = env.applied(&mut self.ctx, parts.method) else { + return self.ctx.fresh(); + }; + let _ = self + .instantiations + .insert(std::ptr::from_ref(site).addr(), fallback.bindings.clone()); + let (count, position, written) = match parts.application { + Some((args, position)) => { + if let Some(position) = position { + self.application_tys.push((position, fallback.bindings)); + } + let binder = self.current_fn_typarams.clone(); + let written = args + .iter() + .map(|arg| self.written_type_argument(arg, &binder, position)) + .collect(); + (args.len().to_string(), position, written) + } + None => ("-".to_owned(), None, Vec::new()), + }; + let arguments = parts + .arguments + .iter() + .map(|arg| self.infer_expr(arg, env)) + .collect(); + let named = parts + .named + .iter() + .map(|arg| Type::con(arg.name.clone(), vec![self.infer_expr(&arg.value, env)])) + .collect(); + let result = self.ctx.fresh(); + let relation = Type::con( + "$method-relation", + vec![ + receiver, + fallback.ty, + Type::fun(arguments, result.clone()), + Type::con( + "$obligations", + fallback + .obligations + .into_iter() + .map(|(name, ty)| Type::con(name, vec![ty])) + .collect(), + ), + Type::con("$binders", fallback.params), + Type::con("$written", written), + Type::con("$named", named), + ], + ); + let line = position.map_or(0, |position| position.line); + let column = position.map_or(0, |position| position.column); + self.builtin_uses.push(( + format!( + "{}{count}:{line}:{column}:{field}:{}", + crate::methods::OBLIGATION, + parts.method + ), + relation, + )); + self.resolve_field_uses(); + result + } + + fn infer_field_call( + &mut self, + receiver: &Type, + field: &str, + parts: &crate::methods::Parts<'_>, + env: &TypeEnv, + ) -> Type { + if let Some((args, position)) = parts.application { + self.errors.push( + TypeError::new(format!( + "function `{field}` takes 0 type argument(s), got {}", + args.len() + )) + .with_pos(position), + ); + } + let ft = self.infer_record_field_type(receiver, field); + let args = self.ordered_arg_types(None, &ft, parts.arguments, parts.named, env); + self.apply_named_fn(None, &ft, args) + } + + fn infer_ufcs_call( + &mut self, + site: &Expr, + receiver: &Type, + parts: &crate::methods::Parts<'_>, + env: &TypeEnv, + ) -> Type { + let ft = match parts.application { + Some((arguments, position)) => { + let callee = Expr::Identifier(parts.method.to_owned()); + let (_, ty) = self.infer_type_application(&callee, arguments, position, env); + if let Some(bindings) = self + .instantiations + .remove(&std::ptr::from_ref(&callee).addr()) + { + let _ = self + .instantiations + .insert(std::ptr::from_ref(site).addr(), bindings); + } + ty + } + None => self.lookup_ident_at(parts.method, env, Some(site)), + }; + let tail = match self.ctx.prune(&ft) { + Type::Fun { params, ret } => Type::fun(params.into_iter().skip(1).collect(), *ret), + other => other, + }; + let mut args = vec![receiver.clone()]; + args.extend(self.positional_arg_types(&tail, parts.arguments, env)); + let mut named: Vec<_> = parts.named.iter().collect(); + if let Some(parameters) = self.fn_params.get(parts.method) { + named.sort_by_key(|arg| parameters.iter().position(|name| name == &arg.name)); } for na in named { args.push(self.infer_expr(&na.value, env)); } - self.apply_named_fn(Some(method), &ft, args) + self.apply_named_fn(Some(parts.method), &ft, args) } /// Resolve call arguments to types, reordering named arguments to the @@ -866,7 +1053,12 @@ impl Checker { param.is_named(names::ANY) && (deferred || matches!(self.ctx.prune(argument), Type::Var(_))) } - fn apply_named_fn(&mut self, name: Option<&str>, ft: &Type, args: Vec) -> Type { + pub(crate) fn apply_named_fn( + &mut self, + name: Option<&str>, + ft: &Type, + args: Vec, + ) -> Type { let constrained_builtin = name.is_some_and(|name| { matches!(name, "length" | "isEmpty" | "print" | "toString" | "toGpu") || crate::builtin_constraints::is_gpu_buffer_builtin(name) @@ -992,13 +1184,13 @@ impl Checker { env: &TypeEnv, expected: Option<&Type>, ) -> Type { - let empty = HashMap::new(); + let binder = self.current_fn_typarams.clone(); let mut local = env.child(); let mut ptys = Vec::new(); let wanted = expected_params(expected, parameters.len()); for (i, p) in parameters.iter().enumerate() { let ty = match &p.ty { - Some(te) => type_expr_to_type(te, &empty), + Some(te) => self.annotation_type(te, &binder, te.position.or(position)), None => wanted.get(i).cloned().unwrap_or_else(|| self.ctx.fresh()), }; local.insert(p.name.clone(), crate::ty::Scheme::mono(ty.clone())); @@ -1034,7 +1226,7 @@ impl Checker { self.resume_ctx = saved_resume_ctx; let ret = match return_type { Some(te) => { - let r = type_expr_to_type(te, &empty); + let r = self.annotation_type(te, &binder, te.position.or(position)); self.push_assign(&r, &body_ty); r } @@ -1076,7 +1268,7 @@ impl Checker { if type_args.len() == args.len() { let binder = self.current_fn_typarams.clone(); for (a, te) in args.iter().zip(type_args) { - let written = crate::convert::type_expr_to_type(te, &binder); + let written = self.written_type_argument(te, &binder, te.position); self.push_unify(a, &written); } } else { @@ -1463,7 +1655,6 @@ fn classify(op: &str) -> OpKind { _ => OpKind::Arith, } } - #[cfg(test)] mod tests { use crate::check::check_program; diff --git a/crates/osprey-types/src/fields.rs b/crates/osprey-types/src/fields.rs new file mode 100644 index 00000000..742bfb4e --- /dev/null +++ b/crates/osprey-types/src/fields.rs @@ -0,0 +1,77 @@ +//! Field constraints carried through ordinary HM schemes. +//! +//! Implements [TYPE-GENERICS-FN] and [TYPE-FIELD-ACCESS-NON-RECORD]: a generic +//! accessor's result must remain related to the record supplied at each call. + +use crate::check::Checker; +use crate::error::TypeError; +use crate::ty::Type; + +const FIELD_OBLIGATION: &str = "$field:"; + +pub(crate) fn obligation_name(field: &str) -> String { + format!("{FIELD_OBLIGATION}{field}") +} + +impl Checker { + /// Resolve instantiated relations until no type or pending work changes. + /// Unresolved receivers remain in the scheme-obligation pipeline. + pub(crate) fn resolve_field_uses(&mut self) { + loop { + let before = self.ctx.bound_count(); + let uses = std::mem::take(&mut self.builtin_uses); + let mut progressed = false; + for (name, ty) in uses { + let solved = self.resolve_method_use(&name, &ty) + || name + .strip_prefix(FIELD_OBLIGATION) + .is_some_and(|field| self.resolve_field_use(field, &ty)); + progressed |= solved; + if !solved { + self.builtin_uses.push((name, ty)); + } + } + if !progressed && self.ctx.bound_count() == before { + return; + } + } + } + + fn resolve_field_use(&mut self, field: &str, relation: &Type) -> bool { + let Type::Fun { params, ret } = relation else { + return false; + }; + let [receiver] = params.as_slice() else { + return false; + }; + let receiver = self.ctx.apply(receiver); + if matches!(receiver, Type::Var(_)) { + return false; + } + match self.resolved_record_field(&receiver, field) { + Ok(actual) => self.push_unify(ret, &actual), + Err(error) => self.errors.push(error), + } + true + } + + pub(crate) fn resolved_record_field( + &self, + receiver: &Type, + field: &str, + ) -> Result { + let fields = match receiver { + Type::Record { fields, .. } => Some(fields.clone()), + Type::Con { name, args } => self.ctx.record_fields(name, args), + _ => None, + } + .ok_or_else(|| { + TypeError::new(format!( + "cannot access field '{field}' on non-struct type {receiver}" + )) + })?; + fields.get(field).cloned().ok_or_else(|| { + TypeError::new(format!("record type `{receiver}` has no field `{field}`")) + }) + } +} diff --git a/crates/osprey-types/src/generics_apply_tests.rs b/crates/osprey-types/src/generics_apply_tests.rs index cd446ad8..6f0a7675 100644 --- a/crates/osprey-types/src/generics_apply_tests.rs +++ b/crates/osprey-types/src/generics_apply_tests.rs @@ -52,8 +52,10 @@ fn type_application_pins_a_binder_no_argument_mentions() { fn the_unpinnable_binder_is_the_control_for_that_case() { rejected_somehow( Flavor::Default, - &format!(r#"{EMPTY}let held = empty() -print("${{length(held)}}")"#), + &format!( + r#"{EMPTY}let held = empty() +print("${{length(held)}}")"# + ), ); } diff --git a/crates/osprey-types/src/generics_variance_assign_tests.rs b/crates/osprey-types/src/generics_variance_assign_tests.rs index b7a3fef3..87e4f6f5 100644 --- a/crates/osprey-types/src/generics_variance_assign_tests.rs +++ b/crates/osprey-types/src/generics_variance_assign_tests.rs @@ -164,7 +164,11 @@ fn every_marker_rejects_an_unrelated_payload() { /// `out` inside `out` recurses, and still bottoms out exact. #[test] fn covariance_inside_covariance_still_bottoms_out_exact() { - blocked(NESTED, "Feed>>", "feedFeedInt()"); + blocked( + NESTED, + "Feed>>", + "feedFeedInt()", + ); flows(NESTED, "Feed>", "feedFeedInt()"); } diff --git a/crates/osprey-types/src/generics_variance_shape_tests.rs b/crates/osprey-types/src/generics_variance_shape_tests.rs index 59395391..40b921eb 100644 --- a/crates/osprey-types/src/generics_variance_shape_tests.rs +++ b/crates/osprey-types/src/generics_variance_shape_tests.rs @@ -24,7 +24,10 @@ fn out_in_a_function_parameter_inside_a_list_is_rejected() { /// The `Result` ERROR channel is an output position too. #[test] fn out_is_legal_in_the_result_error_channel() { - accepts(Flavor::Default, &decl("", "failure", "Result")); + accepts( + Flavor::Default, + &decl("", "failure", "Result"), + ); } /// …so a contravariant parameter is rejected there. @@ -116,17 +119,17 @@ fn mixed_markers_are_checked_per_parameter() { /// Swapping the two markers puts each parameter in the wrong position. #[test] fn swapped_markers_are_rejected_per_parameter() { - let errs = check( - "type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")", - ); + let errs = check("type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")"); assert!( - errs.iter() - .any(|e| e.message.contains(&position_message("A", "in", "output", "give", "Two"))), + errs.iter().any(|e| e + .message + .contains(&position_message("A", "in", "output", "give", "Two"))), "expected the `A` violation: {errs:?}" ); assert!( - errs.iter() - .any(|e| e.message.contains(&position_message("B", "out", "input", "take", "Two"))), + errs.iter().any(|e| e + .message + .contains(&position_message("B", "out", "input", "take", "Two"))), "expected the `B` violation: {errs:?}" ); } diff --git a/crates/osprey-types/src/generics_variance_tests.rs b/crates/osprey-types/src/generics_variance_tests.rs index a8e38e76..ccdf86a4 100644 --- a/crates/osprey-types/src/generics_variance_tests.rs +++ b/crates/osprey-types/src/generics_variance_tests.rs @@ -15,7 +15,13 @@ use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position use osprey_syntax::Flavor; /// The position diagnostic for a type declaration's FIELD. -pub(crate) fn position_message(param: &str, marker: &str, position: &str, field: &str, owner: &str) -> String { +pub(crate) fn position_message( + param: &str, + marker: &str, + position: &str, + field: &str, + owner: &str, +) -> String { variance_position_message(param, marker, position, "field", field, owner) } @@ -53,7 +59,10 @@ fn out_in_a_function_parameter_is_rejected() { /// Two flips compose back to an output position, so `out T` is legal again. #[test] fn out_under_two_parameter_flips_is_legal() { - accepts(Flavor::Default, &decl("", "hof", "((T) -> int) -> int")); + accepts( + Flavor::Default, + &decl("", "hof", "((T) -> int) -> int"), + ); } /// An `in` parameter belongs in an input position. @@ -108,7 +117,10 @@ fn an_invariant_parameter_is_legal_in_both_positions() { fn out_inside_a_covariant_constructor_argument_is_legal() { accepts( Flavor::Default, - &format!("type Feed = {{ supply: A }}\n{}", decl("", "nested", "Feed")), + &format!( + "type Feed = {{ supply: A }}\n{}", + decl("", "nested", "Feed") + ), ); } @@ -117,7 +129,10 @@ fn out_inside_a_covariant_constructor_argument_is_legal() { fn out_inside_a_contravariant_constructor_argument_is_rejected() { rejects_with( Flavor::Default, - &format!("type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate")), + &format!( + "type Gate = {{ admit: (A) -> bool }}\n{}", + decl("", "nested", "Gate") + ), &position_message("T", "out", "input", "nested", "Holder"), ); } @@ -129,7 +144,10 @@ fn out_inside_a_contravariant_constructor_argument_is_rejected() { fn in_inside_a_contravariant_constructor_argument_is_legal() { accepts( Flavor::Default, - &format!("type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate")), + &format!( + "type Gate = {{ admit: (A) -> bool }}\n{}", + decl("", "nested", "Gate") + ), ); } @@ -139,7 +157,10 @@ fn in_inside_a_contravariant_constructor_argument_is_legal() { fn out_inside_an_invariant_constructor_argument_is_rejected() { rejected_somehow( Flavor::Default, - &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + &format!( + "type Cell = {{ slot: A }}\n{}", + decl("", "nested", "Cell") + ), ); } @@ -148,7 +169,10 @@ fn out_inside_an_invariant_constructor_argument_is_rejected() { fn in_inside_an_invariant_constructor_argument_is_rejected() { rejected_somehow( Flavor::Default, - &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + &format!( + "type Cell = {{ slot: A }}\n{}", + decl("", "nested", "Cell") + ), ); } @@ -157,7 +181,10 @@ fn in_inside_an_invariant_constructor_argument_is_rejected() { fn an_invariant_parameter_inside_an_invariant_argument_is_legal() { accepts( Flavor::Default, - &format!("type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell")), + &format!( + "type Cell = {{ slot: A }}\n{}", + decl("", "nested", "Cell") + ), ); } @@ -174,8 +201,14 @@ fn list_is_covariant_in_its_element() { /// `Result`: both arguments are covariant. #[test] fn result_is_covariant_in_both_arguments() { - accepts(Flavor::Default, &decl("", "value", "Result")); - accepts(Flavor::Default, &decl("", "failure", "Result")); + accepts( + Flavor::Default, + &decl("", "value", "Result"), + ); + accepts( + Flavor::Default, + &decl("", "failure", "Result"), + ); } /// `Fiber`: covariant in its answer. @@ -187,7 +220,10 @@ fn fiber_is_covariant_in_its_answer() { /// `Map`: the VALUE is covariant. #[test] fn map_is_covariant_in_its_value() { - accepts(Flavor::Default, &decl("", "byName", "Map")); + accepts( + Flavor::Default, + &decl("", "byName", "Map"), + ); } /// `Map`: the KEY is invariant, so a covariant parameter is rejected. @@ -234,7 +270,11 @@ print("${{firstItem(mkFeed())}}")"# /// Under `out T`. #[test] fn a_result_payload_does_not_collapse_under_a_covariant_container() { - rejects_with(Flavor::Default, &feed_payload_program("out "), "cannot unify"); + rejects_with( + Flavor::Default, + &feed_payload_program("out "), + "cannot unify", + ); } /// Under an invariant parameter. diff --git a/crates/osprey-types/src/info.rs b/crates/osprey-types/src/info.rs index d735f543..e250cb42 100644 --- a/crates/osprey-types/src/info.rs +++ b/crates/osprey-types/src/info.rs @@ -76,6 +76,9 @@ pub struct ProgramTypes { /// Binder identity is part of the contract even when its spelling is omitted. pub(crate) declared_params: HashMap>, pub(crate) call_bindings: HashMap>, + pub(crate) methods: crate::methods::Targets, + /// Generalized source-binding constraints compared by annotation diagnostics. + pub(crate) obligations: HashMap>, } /// One `perform` site's resolved instantiation. @@ -105,7 +108,11 @@ impl ProgramTypes { Type::Con { name, args } => { let layout = self.ctors.get(name)?; let (_, ty) = layout.fields.iter().find(|(name, _)| name == field)?; - let bindings = args.iter().enumerate().filter_map(|(i, ty)| u32::try_from(i).ok().map(|i| (i, ty.clone()))).collect(); + let bindings = args + .iter() + .enumerate() + .filter_map(|(i, ty)| u32::try_from(i).ok().map(|i| (i, ty.clone()))) + .collect(); Some(crate::env::subst_vars(ty, &bindings)) } _ => None, diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index 79414739..eea0b6c5 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -32,6 +32,7 @@ mod effect_rows_tests; mod env; mod error; mod expr; +mod fields; #[cfg(test)] mod generic_effects_tests; #[cfg(test)] @@ -50,6 +51,7 @@ mod generics_variance_shape_tests; mod generics_variance_tests; mod info; mod init_order; +mod methods; mod multiplicity; mod pattern; mod redundant; @@ -69,7 +71,9 @@ pub use builtins::{builtin_callback_type, builtin_signature}; pub use check::{check_program, check_program_exports, erased_var, infer_program}; pub use error::TypeError; pub use info::{CtorLayout, HandlerSite, OpType, PerformSite, ProgramTypes}; -pub use redundant::{redundant_annotations, TypeWarning, REDUNDANT_ANNOTATION}; +pub use redundant::{ + redundant_annotations, redundant_annotations_where, TypeWarning, REDUNDANT_ANNOTATION, +}; pub use ty::{has_type_var, names, render_with_holes, Scheme, Type, VarId, HOLE}; #[cfg(test)] diff --git a/crates/osprey-types/src/methods.rs b/crates/osprey-types/src/methods.rs new file mode 100644 index 00000000..085f661b --- /dev/null +++ b/crates/osprey-types/src/methods.rs @@ -0,0 +1,286 @@ +//! Type-resolved dotted calls become ordinary calls in the backend copy. +//! Implements [BUILTIN-STRING-UFCS]: record fields win before UFCS fallback. + +use osprey_ast::{AstVisitor, Expr, NamedArgument, Position, Program, TypeExpr}; +use std::collections::HashMap; + +pub(crate) type Targets = HashMap; + +#[derive(Clone, Debug, Eq, PartialEq)] +pub(crate) enum Target { + Field(String), + Function, + Deferred(String), +} + +#[derive(Clone, Copy)] +pub(crate) struct Parts<'a> { + pub target: &'a Expr, + pub method: &'a str, + pub arguments: &'a [Expr], + pub named: &'a [NamedArgument], + pub application: Option<(&'a [TypeExpr], Option)>, +} + +pub(crate) fn parts(expression: &Expr) -> Option> { + match expression { + Expr::MethodCall { + target, + method, + arguments, + named_arguments, + } => Some(Parts { + target, + method, + arguments, + named: named_arguments, + application: None, + }), + Expr::Call { + function, + arguments, + named_arguments, + } => { + let Expr::TypeApply { + function, + type_args, + position, + } = function.as_ref() + else { + return None; + }; + let Expr::FieldAccess { target, field } = function.as_ref() else { + return None; + }; + Some(Parts { + target, + method: field, + arguments, + named: named_arguments, + application: Some((type_args, *position)), + }) + } + _ => None, + } +} + +/// Preserve the source field spelling when assembly qualified a free function. +pub(crate) fn field_name(method: &str) -> String { + let source = osprey_ast::symbol::demangle(method).unwrap_or_else(|| method.to_owned()); + source.rsplit("::").next().unwrap_or(&source).to_owned() +} + +pub(crate) fn collect(program: &Program, sites: &Targets) -> Targets { + struct Collector<'a> { + sites: &'a Targets, + index: usize, + targets: Targets, + } + impl AstVisitor for Collector<'_> { + fn expression(&mut self, expression: &Expr) { + if let Some(field) = self.sites.get(&std::ptr::from_ref(expression).addr()) { + let _ = self.targets.insert(self.index, field.clone()); + } + self.index += 1; + } + } + let mut collector = Collector { + sites, + index: 0, + targets: HashMap::new(), + }; + osprey_ast::walk_program(program, &mut collector); + collector.targets +} + +pub(crate) fn lower(expression: &mut Expr, target: &Target) { + let Some(parts) = parts(expression) else { + return; + }; + if matches!(target, Target::Deferred(_)) { + let call = Expr::MethodCall { + target: Box::new(parts.target.clone()), + method: parts.method.to_owned(), + arguments: parts.arguments.to_vec(), + named_arguments: parts.named.to_vec(), + }; + *expression = match parts.application { + Some((args, position)) => Expr::TypeApply { + function: Box::new(call), + type_args: args.to_vec(), + position, + }, + None => call, + }; + return; + } + let mut arguments = parts.arguments.to_vec(); + let function = if let Target::Field(field) = target { + Expr::FieldAccess { + target: Box::new(parts.target.clone()), + field: field.to_owned(), + } + } else { + arguments.insert(0, parts.target.clone()); + Expr::Identifier(parts.method.to_owned()) + }; + let function = match parts.application { + Some((type_args, position)) => Expr::TypeApply { + function: Box::new(function), + type_args: type_args.to_vec(), + position, + }, + None => function, + }; + *expression = Expr::Call { + function: Box::new(function), + arguments, + named_arguments: parts.named.to_vec(), + }; +} + +use crate::check::Checker; +use crate::error::TypeError; +use crate::ty::Type; + +pub(crate) const OBLIGATION: &str = "$method:"; + +impl Checker { + /// A generic dotted call keeps both possible callees until its receiver + /// resolves. The relation travels with the ordinary HM scheme, including + /// variables used only by the selected callee's deferred constraints. + pub(crate) fn resolve_method_use(&mut self, name: &str, relation: &Type) -> bool { + let Some(descriptor) = name.strip_prefix(OBLIGATION) else { + return false; + }; + let mut descriptor = descriptor.splitn(5, ':'); + let explicit = descriptor.next().and_then(|n| n.parse::().ok()); + let line = descriptor + .next() + .and_then(|n| n.parse::().ok()) + .unwrap_or(0); + let column = descriptor + .next() + .and_then(|n| n.parse::().ok()) + .unwrap_or(0); + let Some(field) = descriptor.next() else { + return false; + }; + let Some(method) = descriptor.next() else { + return false; + }; + let Type::Con { args: relation, .. } = relation else { + return false; + }; + let [receiver, fallback, call, obligations, binders, written, named] = relation.as_slice() + else { + return false; + }; + let receiver = self.ctx.apply(receiver); + if matches!(receiver, Type::Var(_)) { + return false; + } + let Type::Fun { + params: arguments, + ret, + } = call + else { + return false; + }; + let position = (line != 0).then_some(Position { line, column }); + let selected = self.resolved_record_field(&receiver, field).ok(); + let mut arguments = ordered_arguments( + arguments, + named, + selected + .is_none() + .then(|| self.fn_params.get(method)) + .flatten(), + ); + let result = if let Some(selected) = selected { + if let Some(count) = explicit { + self.errors.push( + TypeError::new(format!( + "function `{field}` takes 0 type argument(s), got {count}" + )) + .with_pos(position), + ); + } + self.apply_named_fn(None, &selected, arguments) + } else { + self.resolve_method_binders(method, explicit, position, binders, written); + self.builtin_uses.extend(unpack_obligations(obligations)); + arguments.insert(0, receiver); + self.apply_named_fn(Some(method), fallback, arguments) + }; + self.push_unify(ret, &result); + true + } + + fn resolve_method_binders( + &mut self, + method: &str, + explicit: Option, + position: Option, + binders: &Type, + written: &Type, + ) { + let (Some(count), Type::Con { args: binders, .. }, Type::Con { args: written, .. }) = + (explicit, binders, written) + else { + return; + }; + if binders.len() == count { + for (binder, written) in binders.iter().zip(written) { + self.push_unify(binder, written); + } + } else { + self.errors.push( + TypeError::new(format!( + "function `{method}` takes {} type argument(s), got {count}", + binders.len() + )) + .with_pos(position), + ); + } + } +} + +fn ordered_arguments( + arguments: &[Type], + named: &Type, + parameters: Option<&Vec>, +) -> Vec { + let mut arguments = arguments.to_vec(); + let Type::Con { args: named, .. } = named else { + return arguments; + }; + let mut supplied: Vec<_> = named + .iter() + .filter_map(|argument| match argument { + Type::Con { name, args } => args.first().map(|ty| (name, ty)), + _ => None, + }) + .collect(); + if let Some(parameters) = parameters { + supplied.sort_by_key(|(name, _)| parameters.iter().position(|p| p == *name)); + } + arguments.extend(supplied.into_iter().map(|(_, ty)| ty.clone())); + arguments +} + +fn unpack_obligations(obligations: &Type) -> Vec<(String, Type)> { + let Type::Con { + args: obligations, .. + } = obligations + else { + return Vec::new(); + }; + obligations + .iter() + .filter_map(|obligation| match obligation { + Type::Con { name, args } => args.first().map(|ty| (name.clone(), ty.clone())), + _ => None, + }) + .collect() +} diff --git a/crates/osprey-types/src/redundant.rs b/crates/osprey-types/src/redundant.rs index cfcc50d9..b1624269 100644 --- a/crates/osprey-types/src/redundant.rs +++ b/crates/osprey-types/src/redundant.rs @@ -7,11 +7,11 @@ //! the next. The rule is therefore decided by re-running the inferrer over an //! erased copy of the program and comparing what it published. -use std::collections::{BTreeMap, HashMap}; +use std::collections::{BTreeMap, HashMap, HashSet}; use osprey_ast::{Position, Program}; -use crate::check::{check_program, infer_program}; +use crate::check::infer_checked; use crate::redundant_sites::{erase, sites, Site, Slot}; use crate::ty::{Type, VarId}; @@ -41,6 +41,13 @@ pub struct TypeWarning { /// `let`'s type is still an annotation that changed something. type Published = BTreeMap; +/// Equal signatures alone do not prove that dotted calls choose the same +/// implementation. Preserve dispatch choices alongside the inferred types. +struct Snapshot { + types: Published, + methods: crate::methods::Targets, +} + /// Every redundant annotation in `program`, in source order. /// /// An ill-typed program yields none: its inferred types are the checker's @@ -48,36 +55,77 @@ type Published = BTreeMap; /// from comparing them would be trustworthy. #[must_use] pub fn redundant_annotations(program: &Program) -> Vec { - if !check_program(program).is_empty() { - return Vec::new(); - } + redundant_annotations_where(program, |_| true) +} + +/// Select one jointly removable set for the entire program, then report the +/// requested source annotations. Reports for separate files share that set. +#[must_use] +pub fn redundant_annotations_where( + program: &Program, + include: impl Fn(Option) -> bool, +) -> Vec { let written = sites(program); - if written.is_empty() { + if !written.iter().any(|site| include(site.position)) { return Vec::new(); } - let baseline = published(program); - written + let Some(baseline) = published(program) else { + return Vec::new(); + }; + let all: Vec = (0..written.len()).collect(); + let removable = if preserves(program, &baseline, &written, &all) { + all + } else { + accumulate(program, &baseline, &written) + }; + removable .iter() - .enumerate() - .filter(|(index, _)| preserves(program, &baseline, *index)) - .map(|(_, site)| warn(site)) + .filter_map(|index| written.get(*index)) + .filter(|site| include(site.position)) + .map(warn) .collect() } -/// Whether erasing this annotation leaves `program` typechecking -/// and publishing the same types, up to renaming of type variables. +/// Grow the reported set one annotation at a time, in source order, keeping +/// only those that stay removable alongside everything already kept. /// -/// The published types are compared first because they are what usually -/// differs, and re-checking is a second full solve this can then skip. -fn preserves(program: &Program, baseline: &Published, index: usize) -> bool { - let candidate = erase(program, &mut |site| site != index); - same_types(baseline, &published(&candidate)) && check_program(&candidate).is_empty() +/// A reader acts on the whole list, so the whole list has to be safe. Judging +/// each annotation against the untouched program answers a question nobody +/// asked: mutually-pinning annotations each look removable while the others +/// hold the type down, and a reader who deletes all of them gets a different +/// program. Every set this returns has been solved for as a set. +fn accumulate(program: &Program, baseline: &Snapshot, written: &[Site]) -> Vec { + let mut kept: Vec = Vec::new(); + for index in 0..written.len() { + kept.push(index); + if !preserves(program, baseline, written, &kept) { + let _ = kept.pop(); + } + } + kept +} + +/// Whether erasing every annotation in `chosen` — all of them at once — leaves +/// `program` typechecking and publishing the same types, up to renaming of +/// type variables. +/// +/// One checked solve both validates the candidate and publishes its types. +fn preserves(program: &Program, baseline: &Snapshot, written: &[Site], chosen: &[usize]) -> bool { + let erasing: HashSet = chosen + .iter() + .filter_map(|index| written.get(*index)) + .flat_map(|site| site.members.iter().copied()) + .collect(); + let candidate = erase(program, &mut |slot| !erasing.contains(&slot)); + published(&candidate).is_some_and(|candidate| { + baseline.methods == candidate.methods && same_types(&baseline.types, &candidate.types) + }) } /// Everything the inferrer resolved, labelled so two runs compare entry by /// entry. -fn published(program: &Program) -> Published { - let types = infer_program(program); +fn published(program: &Program) -> Option { + let types = infer_checked(program).ok()?; let functions = types.functions.iter().map(|(name, (params, ret))| { let signature = Type::Fun { params: params.clone(), @@ -95,19 +143,45 @@ fn published(program: &Program) -> Published { let _ = published.insert(format!("binder {function} {name}"), ty.clone()); } } + for (owner, obligations) in &types.obligations { + for (index, (name, ty)) in obligations.iter().enumerate() { + let _ = published.insert(format!("constraint {owner} {index} {name}"), ty.clone()); + } + } for (position, site) in &types.performs { - publish_operation(&mut published, &format!("perform {position:?}"), &site.op, &site.effect_args); + publish_operation( + &mut published, + &format!("perform {position:?}"), + &site.op, + &site.effect_args, + ); } for (position, site) in &types.handler_ops { for (operation, op) in &site.ops { - publish_operation(&mut published, &format!("handler {position:?} {operation}"), op, &site.effect_args); + publish_operation( + &mut published, + &format!("handler {position:?} {operation}"), + op, + &site.effect_args, + ); } } - published + Some(Snapshot { + types: published, + methods: types.methods, + }) } -fn publish_operation(published: &mut Published, label: &str, operation: &crate::info::OpType, arguments: &[Type]) { - let _ = published.insert(label.to_owned(), Type::fun(operation.params.clone(), operation.ret.clone())); +fn publish_operation( + published: &mut Published, + label: &str, + operation: &crate::info::OpType, + arguments: &[Type], +) { + let _ = published.insert( + label.to_owned(), + Type::fun(operation.params.clone(), operation.ret.clone()), + ); for (index, argument) in arguments.iter().enumerate() { let _ = published.insert(format!("{label} argument {index}"), argument.clone()); } @@ -130,6 +204,9 @@ fn sited<'a>( fn warn(site: &Site) -> TypeWarning { let written = &site.written; let message = match &site.slot { + Slot::Signature { owner } => format!( + "redundant type signature on `{owner}`: inference derives `{written}` without it" + ), Slot::Param { owner, parameter, .. } => format!( diff --git a/crates/osprey-types/src/redundant_sites.rs b/crates/osprey-types/src/redundant_sites.rs index edf28d3f..9580f718 100644 --- a/crates/osprey-types/src/redundant_sites.rs +++ b/crates/osprey-types/src/redundant_sites.rs @@ -6,16 +6,19 @@ //! needs are one deterministic pre-order walk over the same slots, so this //! module exposes exactly one traversal and two thin drivers over it. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use osprey_ast::mutate::{children_mut, statement_children_mut}; -use osprey_ast::{Expr, Position, Program, Stmt, TypeExpr}; +use osprey_ast::{walk_program, AstVisitor, Expr, Position, Program, Stmt, TypeExpr}; +use crate::check::annotation_name; use crate::convert::type_expr_to_type; /// What a written annotation is attached to, for the diagnostic's wording. #[derive(Debug, Clone, PartialEq, Eq)] pub(crate) enum Slot { + /// One ML signature, including every lowered curry fragment. + Signature { owner: String }, /// A named function or lambda parameter. Param { /// The enclosing function's name (`` for an anonymous one). @@ -44,6 +47,10 @@ const LAMBDA_OWNER: &str = ""; /// One written annotation, addressed by its index in the pre-order walk. #[derive(Debug, Clone, PartialEq, Eq)] pub(crate) struct Site { + /// Slots derived from this one written annotation. + pub(crate) members: Vec, + /// Source identity shared by fragments of a written signature. + source: Option, /// What the annotation is attached to. pub(crate) slot: Slot, /// The written type, rendered. Redundancy means inference derives exactly @@ -68,13 +75,68 @@ pub(crate) fn sites(program: &Program) -> Vec { walk(&mut scratch, &mut |slot, position, annotation| { if let Some(written) = annotation.as_ref().map(render) { found.push(Site { + members: vec![found.len()], + source: annotation.as_ref().and_then(|ty| ty.position), slot, written, position, }); } }); - found + group_signatures(found) +} + +/// Group only fragments with the same recorded source identity. Matching +/// types or matching lambda shapes cannot prove common provenance. +fn group_signatures(sites: Vec) -> Vec { + let mut groups: Vec> = Vec::new(); + let mut sources = HashMap::new(); + for site in sites { + let index = site + .source + .map(|p| (p.line, p.column)) + .map_or(groups.len(), |key| { + *sources.entry(key).or_insert(groups.len()) + }); + match groups.get_mut(index) { + Some(group) => group.push(site), + None => groups.push(vec![site]), + } + } + groups + .iter() + .filter_map(|group| signature_site(group)) + .collect() +} + +fn signature_site(group: &[Site]) -> Option { + let mut site = group.first()?.clone(); + if group.len() == 1 { + return Some(site); + } + let (Slot::Param { owner, .. } | Slot::Return { owner }) = &site.slot else { + return Some(site); + }; + // Keep the outer function's return tail intact: a curried function and + // a flat multi-parameter function have different types and call ABIs. + let params: Vec<_> = group + .iter() + .take_while(|s| matches!(s.slot, Slot::Param { .. })) + .map(|s| s.written.as_str()) + .collect(); + let result = group + .iter() + .find(|s| matches!(&s.slot, Slot::Return { owner: name } if name == owner))?; + site.written = format!("({}) -> {}", params.join(", "), result.written); + site.slot = Slot::Signature { + owner: owner.clone(), + }; + site.position = site.source; + site.members = group + .iter() + .flat_map(|s| s.members.iter().copied()) + .collect(); + Some(site) } /// A copy of `program` with the annotations selected by `keep` removed. @@ -102,13 +164,57 @@ fn render(annotation: &TypeExpr) -> String { type_expr_to_type(annotation, &HashMap::new()).to_string() } -/// Visit written annotations, retaining the types supplied by module contracts. -fn walk(program: &mut Program, visit: Visit<'_>) { - walk_statements(&mut program.statements, &mut |slot, position, annotation| { - if !annotation.as_ref().is_some_and(TypeExpr::is_from_contract) { - visit(slot, position, annotation); +/// ML binders and effect rows share the type header. Type-slot erasure cannot +/// prove that deleting those other parts preserves the function's contract. +fn retained_header(statement: &Stmt) -> Option { + let Stmt::Function { + type_params, + effects, + return_type, + position, + .. + } = statement + else { + return None; + }; + let source = return_type.as_ref()?.position?; + ((!type_params.is_empty() || !effects.is_empty()) + && source.line > 0 + && source.line < position.as_ref()?.line) + .then_some(source) +} + +fn retained_headers(program: &Program) -> HashSet<(u32, u32)> { + #[derive(Default)] + struct Headers(HashSet<(u32, u32)>); + impl AstVisitor for Headers { + fn statement(&mut self, statement: &Stmt) { + if let Some(source) = retained_header(statement) { + let _ = self.0.insert((source.line, source.column)); + } } - }); + } + let mut headers = Headers::default(); + walk_program(program, &mut headers); + headers.0 +} + +/// Visit written annotations, retaining module contracts and non-type headers. +fn walk(program: &mut Program, visit: Visit<'_>) { + let retained = retained_headers(program); + walk_statements( + &mut program.statements, + &mut |slot, position, annotation| { + if !annotation.as_ref().is_some_and(|ty| { + ty.is_from_contract() + || ty + .position + .is_some_and(|p| retained.contains(&(p.line, p.column))) + }) { + visit(slot, position, annotation); + } + }, + ); } /// Walk a statement sequence — a program body, a namespace, or a block. @@ -141,7 +247,13 @@ fn walk_statement(statement: &mut Stmt, visit: Visit<'_>) { } => walk_signature(name, parameters, return_type, *position, &mut *visit), Stmt::Let { name, ty, position, .. - } => visit(Slot::Binding { name: name.clone() }, *position, ty), + } => visit( + Slot::Binding { + name: annotation_name(name), + }, + *position, + ty, + ), _ => {} } statement_children_mut(statement, &mut |expression| { @@ -190,7 +302,7 @@ fn walk_signature( for (index, parameter) in parameters.iter_mut().enumerate() { let slot = Slot::Param { owner: owner.to_string(), - parameter: parameter.name.clone(), + parameter: annotation_name(¶meter.name), index, }; visit(slot, position, &mut parameter.ty); diff --git a/crates/osprey-types/src/redundant_tests.rs b/crates/osprey-types/src/redundant_tests.rs index 68322713..1317a170 100644 --- a/crates/osprey-types/src/redundant_tests.rs +++ b/crates/osprey-types/src/redundant_tests.rs @@ -134,14 +134,13 @@ fn an_ill_typed_program_reports_no_redundancy() { } #[test] -fn a_redundant_generic_signature_is_reported_with_its_binder() { +fn a_redundant_generic_signature_reports_only_what_can_go_together() { + // `-> T` is what keeps the declared binder `T` in use once `x: T` goes, so + // the two cannot both be deleted and only the first is reported. reports( Flavor::Default, "fn identity(x: T) -> T = x\nlet i = identity(42)\n", - &[ - "redundant type annotation on parameter `x` of `identity`: inference derives `T` without it", - "redundant return type annotation on `identity`: inference derives `T` without it", - ], + &["redundant type annotation on parameter `x` of `identity`: inference derives `T` without it"], ); } @@ -168,14 +167,25 @@ fn a_return_annotation_naming_the_wrong_error_type_is_a_type_error_not_a_warning } #[test] -fn ml_and_default_spellings_of_one_signature_report_identically() { - let default = messages(Flavor::Default, GREET); - let ml = messages( +fn each_flavor_reports_the_lines_that_flavor_lets_you_delete() { + // Both surfaces agree the annotation is redundant and agree on the type + // inference derives. They differ in how many warnings that is, because + // they differ in how many things there are to delete: Default writes the + // parameter and the return separately and either can go on its own, while + // ML writes one header line that goes as a whole. + reports( + Flavor::Default, + GREET, + &[ + "redundant type annotation on parameter `name` of `greet`: inference derives `string` without it", + "redundant return type annotation on `greet`: inference derives `string` without it", + ], + ); + reports( Flavor::Ml, "greet : string -> string\ngreet name = \"hi \" + name\n", + &["redundant type signature on `greet`: inference derives `(string) -> string` without it"], ); - assert_eq!(default, ml, "flavors disagreed about the same signature"); - assert_eq!(ml.len(), 2, "{ml:?}"); } #[test] @@ -188,10 +198,7 @@ fn an_ml_module_body_repeating_its_signature_is_still_redundant() { reports( Flavor::Ml, "signature Api\n shout : string -> string\n\nmodule M : Api\n shout : string -> string\n shout s = s + \"!\"\n", - &[ - "redundant type annotation on parameter `s` of `shout`: inference derives `string` without it", - "redundant return type annotation on `shout`: inference derives `string` without it", - ], + &["redundant type signature on `shout`: inference derives `(string) -> string` without it"], ); } @@ -202,10 +209,7 @@ fn a_module_member_annotation_that_is_not_its_contract_is_still_reported() { reports( Flavor::Ml, "signature Api\n shout : string -> string\n\nmodule M : Api\n louder : string -> string\n louder s = s + \"!!\"\n shout s = louder s\n", - &[ - "redundant type annotation on parameter `s` of `louder`: inference derives `string` without it", - "redundant return type annotation on `louder`: inference derives `string` without it", - ], + &["redundant type signature on `louder`: inference derives `(string) -> string` without it"], ); } @@ -322,10 +326,7 @@ fn a_namespaced_function_is_reported_by_its_source_name_not_its_symbol() { reports( Flavor::Ml, "namespace tax\n\nrate : string -> string\nrate band = band + \"%\"\n", - &[ - "redundant type annotation on parameter `band` of `rate`: inference derives `string` without it", - "redundant return type annotation on `rate`: inference derives `string` without it", - ], + &["redundant type signature on `rate`: inference derives `(string) -> string` without it"], ); } @@ -449,3 +450,111 @@ fn an_effect_operation_signature_is_never_reported() { ); } +/// The ML header `smaller : int -> int -> int` with `smaller a b = ...`. +/// One written line; the lowering turns it into a parameter, a curried +/// function-typed return, and a nested lambda carrying the rest. +const CURRIED_ML: &str = "smaller : int -> int -> int\n\ + smaller a b = match a <= b\n true => a\n false => b\n"; + +#[test] +fn a_curried_ml_header_that_monomorphises_a_polymorphic_body_is_kept() { + // `smaller a b = match a <= b ...` generalises to a comparison over any + // one type. The header pins it to `int`, so it is doing real work and no + // part of it is redundant. Judging the lowering's fragments one at a time + // said the opposite — each slot looked derivable because the others were + // still holding the type down — and reported four warnings for a line + // that cannot be deleted. + silent(Flavor::Ml, CURRIED_ML); +} + +#[test] +fn a_curried_ml_header_never_blames_a_lambda_for_a_named_parameter() { + // `b` is a parameter the reader named on the `smaller a b = ...` line. + // Attributing it to `` points at code nobody wrote. + let raised = messages(Flavor::Ml, CURRIED_ML); + assert!( + !raised.iter().any(|m| m.contains("")), + "blamed a lambda for a written parameter: {raised:?}" + ); +} + +#[test] +fn a_genuinely_redundant_curried_header_is_one_warning_naming_the_function() { + // Here the body pins both parameters to `int` on its own, so the header + // really is deletable — and it is ONE line, so it is ONE warning naming + // the function and the whole signature. Reporting `(int) -> int` as the + // "return type" would be the curried remainder, which appears nowhere in + // the source. + reports( + Flavor::Ml, + "combine : int -> int -> int\ncombine a b = intDiv a b ?: 0\n", + &["redundant type signature on `combine`: inference derives `(int, int) -> int` without it"], + ); +} + +#[test] +fn a_default_signature_is_unaffected_by_the_curried_collapse() { + // Nothing curries in Default flavor: each annotation is its own written + // thing and keeps its own warning. The return type stays unreported + // because the body only compares — something has to keep `smaller` at + // `int`, and with both parameters gone that is the return. + reports( + Flavor::Default, + "fn smaller(a: int, b: int) -> int = match a <= b {\n true => a\n false => b\n}\n", + &[ + "redundant type annotation on parameter `a` of `smaller`: inference derives `int` without it", + "redundant type annotation on parameter `b` of `smaller`: inference derives `int` without it", + ], + ); +} + +#[test] +fn a_hand_written_lambda_is_still_reported_against_the_lambda() { + // The collapse is specific to a curry chain the lowering produced. A + // lambda somebody actually wrote still names itself. + reports( + Flavor::Ml, + "exclaim = \\(s: string) => s + \"!\"\nr = exclaim \"hi\"\n", + &["redundant type annotation on parameter `s` of ``: inference derives `string` without it"], + ); +} + +#[test] +fn a_three_argument_curried_header_flattens_all_the_way() { + // Two lambda levels, not one. Collapsing only the first leaves the report + // half-curried — `(string) -> (int) -> (int) -> int` — which is the + // lowering's shape rather than the signature the reader wrote. + reports( + Flavor::Ml, + "clamp : int -> int -> int -> int\nclamp a b c = intDiv (intDiv a b ?: 0) c ?: 0\n", + &["redundant type signature on `clamp`: inference derives `(int, int, int) -> int` without it"], + ); +} + +#[test] +fn the_reported_set_is_deletable_as_a_whole_not_only_one_at_a_time() { + // `pick` is pinned to `int` by its annotations and nothing else: the body + // only compares. Each annotation alone IS removable, because the other two + // still hold the type down — so judging them one at a time reports all + // three. Delete all three and `pick` generalises, which is a different + // program. A reader acts on the whole list, so the whole list has to be + // safe: the rule reports a set it has verified can go together. + let raised = messages( + Flavor::Default, + "fn pick(a: int, b: int) -> int = match a <= b {\n true => a\n false => b\n}\nlet chosen = pick(1, 2)\n", + ); + assert!( + !raised + .iter() + .any(|m| m.starts_with("redundant return type annotation on `pick`")), + "reported every annotation of a mutually-pinned signature: {raised:?}" + ); + assert_eq!( + raised, + vec![ + "redundant type annotation on parameter `a` of `pick`: inference derives `int` without it", + "redundant type annotation on parameter `b` of `pick`: inference derives `int` without it", + ], + "the set must be one the reader can delete whole" + ); +} diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index 67a6ab4e..53e40674 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -2,15 +2,14 @@ **Subsystem:** tree-sitter-osprey, crates/osprey-syntax (both flavors), osprey-ast, osprey-types, osprey-codegen, osprey-lsp -**Status:** The core is implemented and passing tests. Declared type parameters -(fn/type/effect), -declaration-site `in`/`out` variance with position checking and -variance-directed assignability, generic effects with per-site instantiation, -explicit construction-site type arguments, and static proof of the -handler/operation-instantiation seam all work in BOTH flavors. Call-site type -application and the already-documented returned-generic-lambda limitation -remain — see -[§What is left](#what-is-left-detailed). +**Status:** The generics implementation is present in both flavors, including +explicit call-site type arguments, declaration variance, generic effects, +handler inference through helpers and aliases, and specialization metadata for +fibers and nested records. Validation is not green: the completed field-call and generic callback fixes +pass the focused integration matrices, but frozen fixtures conflict +with the settled specification, and pinned Deslop 0.27.0 reports 6.6% +duplication against a 5% gate. Native Windows validation has no local Windows +runner. No CI gate or test is waived. **Spec:** 0004 §Generics/§Variance ([TYPE-GENERICS-*], [TYPE-VARIANCE-*]), 0017 §Generic Effects ([EFFECTS-GENERIC-*]), 0003 §typeParamList/§effectSet, 0024 [FLAVOR-ML-GENERICS] @@ -33,10 +32,11 @@ plain HM unification is untouched, so principal types survive. (check.rs `check_function`, env.rs `generalize`/`instantiate`). - The assignability relation `unify_assignable` models the safe one-way promotion `T -> Result` plus function param-contra/ret-co. The inverse - `Result -> T` is forbidden; declared variance uses this relation. + `Result -> T` is forbidden. Constructor variance has exact leaves; + it never lifts the representation-changing Result promotion through a container. - Codegen specializes generic fns by inlining (genfn.rs), erases `Type::Var` - to `i64` (types.rs:19), and effects run on a name-keyed handler stack - (effects_runtime.c) — fully type-erased. + to `i64` (types.rs), and generic effects use instantiation-mangled runtime + keys. Resolved call substitutions specialize body metadata before lowering. ## Previous gaps @@ -120,30 +120,28 @@ plain HM unification is untouched, so principal types survive. - Float payloads crossing erased effect slots must use bitcast boxing (`box_to_i64`), never `coerce_to`'s numeric `fptosi`. -## What is left (detailed) +## Follow-up implementation and boundaries -The declared-generics + variance + generic-effects core is done. Three -follow-ups are known-incomplete, each with a concrete failing repro today: +The declared-generics, variance, generic-effects, and explicit-application +surfaces are implemented. The following records their final behavior and limits: ### 1. Call-site type application (turbofish) — `identity(5)` -**State:** unsupported. `identity(5)` parses `int` as a *value* -identifier and errors `unknown identifier int`; the spec only ever shows -`identity` in comments, never as callable syntax. Declaration-site -binders (`fn map`) and construction-site args (`Box { … }`) work; -the call-site form does not. - -**Why it matters:** the only way to pin an otherwise-unconstrained -polymorphic return today is an annotated `let` (`let x: int = identity(5)`); -turbofish is the direct spelling the docs imply. - -**Scope:** grammar (`call_expression` needs a `< typeList >` postfix that -does not collide with `<` comparison — the same GLR/lookahead hazard the -construction-site form already solved), a `type_args` field on `Expr::Call`, -lowering in both flavors, and a checker step that unifies the call's -instantiation variables against the written arguments (reuse -`current_fn_typarams` threading from construction sites). ML spelling TBD -(angle-bracket `f(x)` vs a signature-only story). +**State:** implemented. Default writes `identity(5)`; ML writes +`identity 5`. The angle run is recognized only when its full type-shaped +contents close before a valid call argument, preserving comparisons such as +`x<3` and `x`, is rejected before conversion can discard them. + +`applications.rs` carries implicit and explicit call substitutions across the +backend AST copy. Alias origins compose into that substitution, and generic +body metadata for effect operations, handlers, lists, lambdas, and nested +records specializes at each call. Source positions remain available for +compiler diagnostics. An unconstrained immutable `let` can still generalize; +explicit type arguments are a way to pin its type, never a requirement. ### 2. Generic functions as first-class values — ✅ landed (plan 0002) @@ -154,8 +152,8 @@ generic HOFs dispatch indirectly (`fn also(x, f) = f(x)` applied at two instantiations works). The enabling checker fix: builtin scheme binder ids (`Var(0)`/`Var(1)`) no longer collide with live inference variables (`RESERVED_SCHEME_VARS`), which had been silently blocking let-generalization -of `-> T`-annotated functions. Plan 0002 still rejects a generic lambda returned -from a generic function. +of `-> T`-annotated functions. A returned generic lambda can be bound and specialized when called. A still-generic +closure used as a bare value without a concrete consuming slot is rejected. ### 3. Static proof of the handler/operation instantiation seam — ✅ landed @@ -210,11 +208,12 @@ executable assertions. Each is recorded with the evidence that settles it. The two shipped fixtures could not see this: both assert the one direction all three markers already agree on. -2. **`Map`'s "(keys invariant)" describes an uninstantiable - parameter.** The shipped map surface fixes keys to `string` - ([BUILTIN-MAP-GET], spec 0012), so no program can write `Map` and - the key's variance is unobservable. Spec 0004's built-in table and spec 0012 - disagree about whether `K` exists. +2. **Map type notation and constructible values are distinct.** The type + system retains `Map` with invariant `K`; shipped constructors, + literals, lookup, and updates constrain `K` to `string` ([TYPE-MAP], + [BUILTIN-MAP-GET]). A type argument can name `Map`, but no shipped + map constructor builds such a value. The invariant key parameter does not + imply support for integer-keyed maps. 3. **The dynamic-instantiation diagnostic contradicts the runtime it cites.** `examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo` @@ -229,8 +228,8 @@ executable assertions. Each is recorded with the evidence that settles it. angles are legal on a ROW (`!Stash`), and the written mention belongs to `static effect`, whose identity IS the instantiation. - **Replacement diagnostic** (same rule, true reason — the fixture golden is - updated in the same commit that emits it): + **Replacement diagnostic** (same rule, true reason; the frozen fixture + golden remains stale and is a validation blocker): > ``perform Signal`` names an instantiation of dynamic effect > ``Signal``; a written instantiation is the identity of a ``static effect``, @@ -238,10 +237,9 @@ executable assertions. Each is recorded with the evidence that settles it. > (docs/plans/0024-staged-effects.md). Declare ``static effect Signal``, or > write ``perform Signal`` and let inference instantiate it -4. **Spec 0017 writes `handle … do`; the language accepts `in`.** Intended: - the Default flavor is moving to `do` ([plan 0027](0027-arithmetic-effects.md) - phase 0). `the_spec_writes_a_handled_body_after_do` is a deliberate red pin - that turns green when that rename lands. +4. **Handler body spelling is explicit.** Default accepts `handle ... in` + and the compatibility spelling `handle ... do`. ML accepts `in`. The + `the_spec_writes_a_handled_body_after_do` assertion now passes. ## TODO @@ -260,16 +258,16 @@ Core (done): - [x] LSP symbol/hover rendering of type params - [x] Examples expanded in both flavors + 7 failscompilation cases - [x] Specs 0002/0003/0004/0017/0023/0024 updated -- [x] make ci green +- [ ] make ci green — blocked; see validation and frozen-test conflicts -Remaining: +Follow-ups: -- [ ] **Call-site type application** `identity(5)` — grammar + - `Expr::Call.type_args` + both-flavor lowering + checker unification - (§What-is-left 1). **Specified and pinned red first**: the contract is +- [x] **Call-site type application** `identity(5)` — grammar + + `Expr::TypeApply` + both-flavor lowering + checker unification + (§Follow-up 1). The contract is [spec 0004](../specs/0004-TypeSystem.md) `[TYPE-GENERICS-APPLY]` and [spec 0024](../specs/0024-MLFlavorSyntax.md) `[FLAVOR-ML-GENERICS]`; the - failing assertions are `crates/osprey-types/src/generics_apply_tests.rs` + assertions are `crates/osprey-types/src/generics_apply_tests.rs` (Default), `generics_apply_ml_tests.rs` (ML), four CST cases in `tree-sitter-osprey/test/corpus/osprey.txt`, and the corpus twins `tests/regressions/basics/types/type_equality_comprehensive.test.osp{,ml}` @@ -278,25 +276,22 @@ Remaining: shipped contract is [spec 0004](../specs/0004-TypeSystem.md) `[TYPE-GENERICS-FN]`: slot-driven specialization + let-alias + inline fn-typed arg registration; `let g = identity` passed to a HOF compiles and runs - (§What-is-left 2). Only the returned still-generic lambda remains, in - plan 0002. + (§Follow-up 2). Bare generic closure values still require a concrete + consuming slot. - [x] **Static handler/operation seam** — resolved operation summaries make an instantiation mismatch a compile error; explicit rows are contracts, and - the runtime null guard is only a backstop (§What-is-left 3 and + the runtime null guard is only a backstop (§Follow-up 3 and [plan 0016](0016-algebraic-effects-and-handlers.md)). -- [ ] failscompilation cases for turbofish once it lands — already written and - red: `turbofish_type_arg_arity`, `turbofish_type_arg_too_few`, +- [x] Explicit-application rejection checks are implemented. Frozen cases include: `turbofish_type_arg_arity`, `turbofish_type_arg_too_few`, `turbofish_no_declared_binder`, `turbofish_argument_contradiction`, `turbofish_variance_marker`, `ml_turbofish_type_arg_arity` and `ml_turbofish_no_declared_binder` in `examples/failscompilation/`. -- [ ] The adjacent spec surface is pinned by the same sweep and may expose - defects of its own: `generics_decl_tests.rs` +- [x] The adjacent declaration and variance surface is implemented and checked: `generics_decl_tests.rs` ([TYPE-GENERICS-DECL], [GENERICS-CTOR-ARITY], [TYPE-GENERICS-FN]), `generics_variance_tests.rs` ([TYPE-VARIANCE-*], including the built-in variance table checked through position composition) and `generic_effects_tests.rs` ([EFFECTS-GENERIC-*], plus the - `handle … do` spelling spec 0017 writes and the language does not accept — - [plan 0027](0027-arithmetic-effects.md) phase 0 owns that rename). + the accepted Default `handle … do` compatibility spelling). ## Frozen-test conflicts (2026-09-09, second sweep) @@ -391,13 +386,11 @@ the argument the application applies to — mirroring `at_generic_record`. `send` likewise stopped being a hard keyword in the three positions that hold an effect operation name ([FLAVOR-ML-EFFECT-OP-NAME]). -**The same regression is still live in the Default flavor** and is the one -outstanding defect this sweep found in shipped behaviour: `fn lit(x) = x<3` is a -syntax error, while the spaced `x < 3` compiles. The fix belongs in -`tree-sitter-osprey/grammar.js`, and it is the rule the ML side now follows — a -glued `<` may not commit to type arguments on its own; the whole shape must be -there, a balanced angle run of type-only tokens followed by the argument the -application applies to. +The Default comparison regression is also fixed. Its external scanner checks +balanced, type-shaped arguments and the following call delimiter before +committing to the angle application. `x<3`, `x(5)` +compile together. The frozen nested-application CST expectation still has +one mismatched closing parenthesis; parser behavior is correct. Two failures in this sweep are **not** generics work: @@ -410,3 +403,229 @@ Two failures in this sweep are **not** generics work: no longer reach codegen: `GENERIC_AS_VALUE` is caught by the checker, so their `stderr` never says `codegen` and **no program exercises the CLI's codegen-error path**. That path needs a program that still fails there. + +## Final review and validation (2026-09-09) + +The implementation review corrected call-site specialization through aliases, +generic effects under helper-installed handlers, metadata for nested generic +records, and Default glued comparisons. A mixed executable probe combines +covariant records, a contravariant effect, polymorphic helpers, inferred and +written applications, fibers, dynamic handlers, resume, Results, lists, maps, +closures, and aliases. Its Default and ML forms both pass under default, GC, +and ARC memory management. Temporary probes live outside the repository; no +frozen assertions were weakened to obtain these results. + +The warning review found a real false positive on the inbox's +`Markdown::smaller`. One written ML signature had been copied onto several +canonical slots, and erasing one copy left the others supplying the constraint. +Lowering now preserves their shared source position; the detector erases all +copies together. The actual inbox project produces no `smaller` warnings. +Curried types retain their curried shape in diagnostics; `(int) -> (int) -> int` +and `(int, int) -> int` are different types. Existing Default annotations stay +separate source annotations. The warning pass chooses one jointly removable set +for the entire assembled program before filtering by open file. Per-file +selection cannot prove that annotations in different files are removable +together. The latest local LSP library run took 44.32 seconds; the earlier +5.95-second result used the now-replaced per-file selection shortcut. + +The following table records the earlier CI snapshot. The completed instrumented +workspace rerun and corpus matrix are recorded after the integration notes below. + +| Check | Result | +| --- | --- | +| Full instrumented workspace run | 1515 passed, 21 failed across 7 targets | +| Release CLI build | Passed | +| Production Clippy (`--workspace --lib --bins -- -D warnings`) | Passed | +| `make hawk` | Passed, zero findings | +| Native Default corpus | 209 passed, 2 frozen invalid fixtures failed | +| Native ARC corpus | 209 passed, same 2 failed; zero reported leaks | +| Wasm corpus | 144 passed, same 2 failed; 65 pre-existing declared capability exclusions | +| Alternative GPU lowering | 18 passed in each corpus run | +| Type checker unit tests | 511 passed, 7 frozen expectations failed | +| LSP unit tests | 159 passed, 6 frozen expectations failed | +| Codegen unit tests | 124 passed | +| Tree-sitter corpus | 17 passed, 1 malformed frozen CST expectation failed | +| Bank native suites | 3 passed | +| Mobile inbox domain tests | 32 passed | +| Formatting | Passed on current working tree; pre-existing test formatting edits preserved | +| All-target Clippy | Blocked by five lints in frozen tests/test helpers | +| `make ci` | Pinned Deslop 0.27.0 runs and rejects approximately 6.6% duplication against the unchanged 5% ceiling | + +The seven type-checker failures comprise the five semantic/phase conflicts +listed above and two warning fixtures that flatten a curried type in their +expected text. The six LSP failures expect no diagnostics for programs with +redundant written annotations; the returned diagnostics are Warnings, not +syntax/type errors. The tests remain validation blockers. The final workspace +run and rejection goldens must not be described as green, and no PR may be +submitted while `make ci` fails. + +### CI preparation follow-through (2026-09-09) + +The delegated audit found and corrected additional production defects: explicit +constructor and effect-row arguments now use the same validation as function +applications; rows reject wrong written arity even when their bodies perform no +operations. Parameters, returns, local bindings, and lambda annotations reject +applications of an enclosing type variable such as `T`. Local and lambda +annotations resolve the enclosing function's declared binders. The native +mixed-type local/lambda probe prints `7 ok`. + +ML standalone signatures and inline parameter annotations both constrain the +checker. A disagreement is rejected. A whole signature retains its curried +shape in warning text, and headers declaring generic binders or effect rows are +conservatively retained because type-only erasure does not model deleting those +declarations. LSP analysis traverses explicit type applications while recovering +from invalid callees, preserving hover information inside those expressions. + +The delegated local CI runs additionally establish: + +| Job or gate | Result | +| --- | --- | +| Branch protection | Two active rulesets; all 14 required contexts match | +| VS Code extension | 316 tests passed; all four coverage metrics exceed 95% | +| Extension lint, manifest, VSIX packaging | Passed | +| Website Chromium E2E | 107 passed, including both Wasm flavors and smoke hosts | +| Bank Chromium E2E | 17 passed against rebuilt compiler | +| Docker web compiler | Image built; actual container API assertion passed | +| C runtime | 24 suites passed; 29 library coverage gates passed | +| iOS | Device/simulator builds, ABI, Counter and Inbox smoke passed; corpus 128/130 with the same two frozen invalid fixtures | +| Android | App build, ABI/domain tests, smoke and Gradle lint passed; corpus 128/130 with the same two frozen invalid fixtures | +| Additional checks | Runtime incremental build, profiler, benchmark tooling, and node dependency guard passed | +| Windows | Not executable on this host: native Windows/MSYS2 UCRT64 runner or VM is absent | + +The exact CI Rust command fails on frozen CLI diagnostic expectations. The earlier +instrumented run with `--no-fail-fast` exposed seven failed targets; it is +not a green coverage run. Existing Rust coverage report thresholds passing is +not evidence that this failed run completed successfully. + +The independent pinned duplication audit classifies 3,357 counted lines as +frozen tests and 2,510 as production. This corrects an earlier classification +that missed attributes between `#[cfg(test)]` and test modules. Even the +unachievable optimistic case of removing all 919 strong production clone lines +from the numerator alone leaves 5.574%. The reviewed production consolidation +families do not establish safe sufficient savings. The gate remains unchanged; +no tests, exclusions, or thresholds were modified to obtain a pass. Exact spans, +overlap accounting, candidate remedies, and validation are recorded in +`/tmp/osprey-final-deslop-findings.md`. + +### Final field, callback, and fiber integration + +Generic field constraints now retain the relationship between a receiver and +its field through HM generalization, aliases, and call-site instantiation. +Hidden callback variables travel with that relation. The checker rejects +wrong callback result types and nonrecord receivers before code generation. + +Dotted calls preserve field precedence until the receiver is resolved. A +single generic helper can select a record field at one call and a free +function at another, including distinct result types. Explicit type arguments +apply only to the selected callable's declared binders. Named UFCS arguments +retain the implicit receiver. Effect summaries defer the same choice and +preserve callback effects, returned callables, handler exclusions, and exact +generic effect identity. Unknown provenance is not proof that a field is +absent. The warning oracle compares generalized constraints and dispatch +choices as well as the previously published types. + +Closure parameters, captured callbacks, and returned function values carry +full semantic types across their ABI slots. This fixes a float getter that +printed integer bits, an invoked callback emitted as an unresolved free +function, and generic effectful functions stored in fields. Inlined list +literals are materialized before crossing a fiber result boundary, fixing a +segfault when awaiting a boxed generic fiber returning nested lists. + +The final focused evidence includes 47 dispatch/corpus cases, 58 check/LLVM +outcomes across 29 effect/dispatch probes, 39 additional runtime checks and +five rejection probes, and the 36-case fiber matrix. These are overlapping +validation sets, not a count of distinct regression tests. The stable release +SHA256 is `2807bb3a92e19423737d7a5313e1330261f2ed568ef98a15134a545823e8f46e`. +Existing codegen tests pass 124/124 and effect tests pass 93/93. No repository +tests were changed by this delegation. + +Both large type-equality twins pass all 33 assertions and match their existing +golden after the malformed inputs are repaired only in temporary copies. +Their helper contracts also differ: Default annotates `keepSource` and +`keepSink` concretely, while ML generalizes them. Removing those two Default +annotations in the temporary copy preserves generic coverage and yields +byte-identical IR. This is a further frozen fixture correction, recorded in +`/tmp/osprey-ci-frozen-corrections.md`; the repository copies remain unchanged. + +The user requested deleting this plan **once done**. Its CI acceptance condition +is still unmet, so the plan remains until the frozen-test conflicts, duplication +gate, and Windows validation are resolved. No PR has been opened. + +### Completed verification after backend integration + +The full instrumented Rust workspace run reports **1,514 passed and 22 failed +across eight targets** (`/tmp/osprey-ci-final-rust.log`). The additional failure +is the frozen Default AST expectation that rewrites `o.m(1)` before receiver +typing; the implementation now correctly preserves `MethodCall`. This failed +run is not a green coverage result. + +The sequential corpus matrix completed with compiler SHA256 +`73137670037536be5137972efa68916ebf6b234b6c29f8ebf8c4d221184af0f7`: + +| Target | Result | +| --- | --- | +| Native assertions and stdout goldens | 209 passed, the same two frozen invalid twins failed | +| GC stdout goldens | 209 passed, the same two failed | +| ARC stdout goldens | 209 passed, the same two failed; zero reported leaks | +| Wasm stdout goldens | 144 passed, the same two failed; 65 existing declared capability exclusions | +| Alternative GPU lowering | 18 passed in each golden matrix | + +Exact commands, logs, and the stable compiler hash are recorded in +`/tmp/osprey-ci-final-corpora.json`. These runs precede the final checker review +of builtin shadowing and callback-return effect provenance; they are evidence +for the integrated backend, not a claim that every subsequent checker revision +has passed a complete CI run. + +The proposed frozen-fixture correction set is concrete and unapplied at +`/tmp/osprey-frozen-corrections.patch`. Its applicability check passes, and all +769 protected file hashes match the test-freeze baseline. Applying it still +requires an explicit exception to the user's test freeze. Production formatting +and Clippy pass; all-target Clippy still reports five frozen test/helper lints. + +### Final effect-provenance review + +The review additionally fixed three ways effect information could be lost: +builtin result shapes applied to shadowing user bindings; a callback application +was represented by its callee rather than its returned value; and a failed field +projection retained a callee parameter index that could later resolve through an +unrelated caller argument. Supplied opaque values now stay unknown; only truly +absent arguments retain symbolic binders. Generic field calls cannot use an +unrelated pure callback to discharge an effectful field. + +Callback return projections and higher-order invocations retain positional and +named argument values. Scope shifting, substitution, fixed-point widening, and +handler exclusion traverse that retained provenance. Named and curried calls +therefore preserve the effects of callbacks actually invoked by the callee. +Active handler return values are keyed by operation and complete generic effect +instantiation. Closures capture values without capturing handler bindings, so +escaping a handler does not erase a returned callable's remaining requirements. + +On frozen release SHA256 +`8ef9a57c7d23af2e7a472861d7110ecf6e235e47364e1e5d7e17037cd03a2dc6`, +the existing effect suite passes **93/93**, the final checker/LLVM matrix passes +**142/142** decisions, and ten accepted cases pass **30/30** native runs across +default, GC and ARC with exact expected output. Cases include `Factory` +returning a record, exact and wrong `Probe` handlers, escaped captured +records, lexical shadowing, ignored/invoked callbacks, and named/curried calls. +The matrix overlaps earlier focused checks; it is not a count of new repository +tests. Evidence is in `/tmp/osprey-failed-projection-report.md`. + +The final full instrumented workspace run against this source completed with +**1,514 passed and the same 22 failed across eight targets** +(`/tmp/osprey-ci-verified-rust.log`). Totals exclude a nested one-test subprocess +already counted by its parent suite; earlier totals that included it were one +too high. Codegen passes 124/124, LSP reports 159 passed and six frozen failures, +and types reports 511 passed and seven frozen failures. The run is not a green +coverage result. + +Final formatting, production workspace Clippy, and the Hawk dead-code gate pass. +The assembled inbox checks successfully with 175 statements and no +`Markdown::smaller` warnings; its one remaining warning names the whole curried +`Text::boundary` signature. The pinned `make ci` run still fails at **6.6% +duplication (5,867 / 88,916 LOC)** against the unchanged 5% ceiling. The logs are +`/tmp/osprey-ci-verified-{format,production-clippy,hawk,inbox,gate}.log`. + +The correction patch still passes `git apply --check`, all 769 protected files +remain unchanged, and the user has not authorized an exception to the test +freeze. No native Windows runner is available. These blockers keep the CI +checkbox open; the plan is retained and no PR has been created. diff --git a/docs/specs/0004-TypeSystem.md b/docs/specs/0004-TypeSystem.md index 0aac071f..08325307 100644 --- a/docs/specs/0004-TypeSystem.md +++ b/docs/specs/0004-TypeSystem.md @@ -381,7 +381,8 @@ createAdder : int -> int -> int createAdder n = \x => x + n ``` -Multi-argument call syntax (named arguments are required for two or more parameters) is in [Function Calls](0005-FunctionCalls.md). +Multi-argument calls accept positional arguments or a fully named argument +list, as specified in [Function Calls](0005-FunctionCalls.md). ### Closures — [TYPE-FN-CLOSURE] @@ -890,25 +891,63 @@ reading the annotation: `string -> int -> string` is redundant on one function and load-bearing on the next. It is decided by inference, and only by inference. -**The decision procedure.** Start from a well-typed program. Erase exactly one written parameter, return, lambda, or binding annotation from a copy of that program and run inference again. Compare all solved function, binding, lambda, list, handler, and operation types, including effect arguments and the relationships between declared generic binders and those types. The comparison uses one consistent bijection between inference variables. Report a warning only when the copied program remains well-typed and every compared type is equal under that renaming. Any changed type, changed binder relationship, or type error keeps the annotation. - -Each warning is evaluated against the original program with its other annotations present. Several independent warnings do not prove that all their annotations can be removed together. For example, either annotation in `fn identity(x: T) -> T = x` can individually be inferred from the other; deleting both would disconnect the declared `T` from the function's parameter. Re-run diagnostics after a deletion. An ML signature header is one source construct containing several canonical slots; deleting its whole header requires checking the whole edit. +**The decision procedure.** Replace the annotations under test with fresh type +variables, solve, and generalise. Compare every type the solver publishes to +the types it published for the untouched program, up to renaming of bound type +variables. Equal ⇒ redundant. Different, or no solution ⇒ the annotations were +constraining something and are kept. + +The comparison includes local, lambda, and list types, declared binders, +operation and handler instantiations, and generalized field or callable +constraints. It also preserves each dotted call's selected field, free +function, or deferred selection rule ([BUILTIN-STRING-UFCS]). Matching only +the enclosing function's parameter and return types is insufficient: removing +an annotation must not change a callback's requirements or the implementation +selected by a call with the same result type. + +**Redundancy is a property of a set, not of one annotation.** Annotations pin +each other. In `fn pick(a: int, b: int) -> int = match a <= b { ... }` the body +only compares, so nothing forces `int` except the annotations themselves — and +each one alone is removable, because the other two still hold the type down. +Judged one at a time, all three report; delete all three and `pick` generalises, +which is a different program. A reader acts on the whole list, so the whole list +is what gets solved for: the rule reports a set it has verified can be deleted +together, growing it in source order and dropping any annotation that stops +being removable alongside the ones already reported. What it reports is +therefore always true of the report as a whole — delete every warning it gives +you and the program's types are unchanged. + +The same coupling is why a lowered signature is judged whole. ML writes a +signature as one arrow type, and lowering splits it across a parameter, a +curried function-typed return and a nested lambda holding the rest. Those +fragments hold each other up, so judging them apart reports a header that +cannot be deleted at all — four warnings for one line, one of them blaming a +`` for a parameter the reader named. Fragments of one written type are +one unit: judged together, erased together, and reported once. + +An ML header that also declares generic binders or an effect row is retained. +The current erasure pass removes type constraints, not those declarations, so +it cannot prove that deleting such a header preserves the complete contract. +An inline parameter annotation alongside a standalone header remains a separate +constraint: both are checked, disagreement is rejected, and removing either +annotation leaves the other present. ```mermaid flowchart LR - A["written annotation"] --> B["erase → fresh var"] + A["written annotations"] --> B["erase the whole set → fresh vars"] B --> C["infer + generalise"] - C --> D{"solved type
vs written"} - D -- "alpha-equal" --> E["redundant — report"] - D -- "strictly more general" --> F["constraining — keep"] - D -- "no solution" --> F + C --> D{"solved types, constraints
and dispatch vs baseline"} + D -- "equivalent" --> E["the set is redundant — report it"] + D -- "differs, or no solution" --> F["drop the last one and retry"] + F --> B ``` **Where it applies.** Function parameter annotations, function return annotations, lambda parameter annotations, and binding annotations, in both -surfaces ([FLAVOR-BOUNDARY]) — an ML `f : string -> int` header and a Default -`fn f(x: string) -> int` are the same canonical annotation and are judged -identically. +surfaces ([FLAVOR-BOUNDARY]). Both use the same type-equivalence rule. An ML +`f : string -> int` header is one source annotation; a Default +`fn f(x: string) -> int` contains two independently removable annotations. +Their diagnostic counts therefore need not match. ```osprey-ml (** Both slots are inferred as string from concatenation. *) @@ -945,18 +984,32 @@ compiles and runs exactly as it did. Severity is fixed today and becomes configurable per rule; the rule identifier is `redundant-annotation`, and it is that identifier a future configuration names. -**The message** identifies the annotation and prints the type inference derives -without that slot. There is -one line per slot the rule judges: +**The message** identifies the written annotation and prints the type inference +derives without it. There is one line per written annotation the rule judges: ``` redundant type annotation on parameter `key` of `numField`: inference derives `string` without it redundant return type annotation on `numField`: inference derives `string` without it redundant type annotation on `seen`: inference derives `List` without it -``` - -An annotation written on an anonymous function names `` as its owner, -and a name that assembly mangled is reported in its source spelling +redundant type signature on `decorate`: inference derives `(string) -> string` without it +redundant type signature on `combine`: inference derives `(int) -> (int) -> int` without it +``` + +The last shape is one whole curried signature. Its nested arrows are preserved: +`int -> int -> int` takes one argument and returns another function, whereas +`(int, int) -> int` takes two arguments in one call. These types have different +call conventions and diagnostics must not flatten one into the other. +ML spells a signature as a single arrow +type on its own line, and lowering splits it across a parameter, a curried +function-typed return and a nested lambda holding the rest. Those fragments are +one written line: they are judged together, erased together, and reported once, +naming the function. Judging them apart is not merely noisier, it is wrong — +each fragment looks derivable while the others still hold the type down, so a +header that cannot be deleted gets reported anyway. + +An annotation written on an anonymous function names `` as its owner; +an implicit curry lambda is not a written anonymous function. A name that +assembly mangled is reported in its source spelling ([MODULES-ABI](0025-ModulesAndNamespaces.md#name-mangling-and-abi-modules-abi)), so `bank::Api::json` is never shown as its encoded symbol. @@ -965,4 +1018,4 @@ grouped by source file under an aligned `line:column` gutter and closed by a count and the rules that raised it; and the language server as a Warning diagnostic anchored at the containing declaration and spanning the rest of that source line ([LSP-DIAGNOSTICS](0020-LanguageServerAndEditors.md#diagnostics-lsp-diagnostics)), -The message names the parameter, return, or binding slot. The range identifies the declaration; it is not a deletion edit. The compiler does not offer an automatic bulk deletion based on these independent warnings. +The message names the written signature, parameter, return, or binding annotation. An ML signature range starts at its header. Other ranges identify the containing declaration. A range is not a deletion edit. The compiler does not offer an automatic deletion action. For an assembled project, the safe set is chosen for the entire program before filtering diagnostics to an open file, so opening a different file cannot change which annotations are reported as removable. diff --git a/docs/specs/0005-FunctionCalls.md b/docs/specs/0005-FunctionCalls.md index 00044ac5..4f4d3314 100644 --- a/docs/specs/0005-FunctionCalls.md +++ b/docs/specs/0005-FunctionCalls.md @@ -1,6 +1,10 @@ # Function Calls -Default calls lower to one `Expr::Call`. ML whitespace application and +Ordinary Default calls lower to one `Expr::Call`. Dotted calls retain their +receiver until its type determines field access or UFCS fallback +([BUILTIN-STRING-UFCS](0012-Built-InFunctions.md#calling-style--builtin-string-ufcs)). +For a generic receiver this selection occurs at each instantiation. +ML whitespace application and uncurried grouping lower to the same node shapes as described in [FLAVOR-CURRY](0023-LanguageFlavors.md#currying-canonicalisation) and [FLAVOR-ML-CALL](0024-MLFlavorSyntax.md). @@ -39,6 +43,11 @@ parameter order. The grammar does not permit positional and named arguments in one argument list. Unknown and duplicate argument names are not rejected consistently; a named call must use each declared name exactly once. +In a UFCS call such as `receiver.f(second: value)`, the receiver supplies the +first declared parameter. Written names supply the remaining parameters in +declaration order. The implicit receiver is preserved even though the written +argument list is named. + The ML equivalent of the flat two-parameter function is uncurried application: ```osprey-ml diff --git a/docs/specs/0011-LightweightFibersAndConcurrency.md b/docs/specs/0011-LightweightFibersAndConcurrency.md index 10735bd1..17d77682 100644 --- a/docs/specs/0011-LightweightFibersAndConcurrency.md +++ b/docs/specs/0011-LightweightFibersAndConcurrency.md @@ -75,15 +75,15 @@ the element type erased, and a collection crosses the wire in the runtime representation a receiver can read — a backend may not put a construction-time layout on a channel that only its own scope knows how to interpret. -One route does NOT carry `T`, and it is REJECTED rather than guessed at: a -handle stored in a field whose DECLARED type is a type variable — `type Box = -Box { slot: t }` — reaches `recv` with nothing to unbox by, because the -declaration is all the field read has. `recv` and `await` refuse such a program -and name the field. They used to fall back to the uniform wire word, which is a -plausible WRONG VALUE and not an error: a `Channel>>` read out of -such a field answered its outer shape as an integer, so reading a row out of it -produced `0` where the answer was `3` — exit status 0, no diagnostic, nothing to -notice. The same rule and the same refusal apply to `Fiber`. +A handle stored in a generic field also preserves its resolved type. For +`type Box = Box { slot: t }`, a field containing +`Channel>>` carries the instantiated channel element type into +`recv`; a field containing `Fiber` carries the instantiated result type into +`await`. Field access uses the solved instance, including through aliases and +nested records. It must never guess from the erased machine word. A backend +that cannot recover this metadata must reject the program with a diagnostic. +The former metadata-loss reproduction sends `[[1, 2, 3]]` through a boxed +channel and now correctly reports row length `3` rather than `0`. A managed `T` handed to `send` is OWNED by the channel until a `recv` takes it. A send the runtime rejects owns nothing and releases the value again; a value diff --git a/docs/specs/0012-Built-InFunctions.md b/docs/specs/0012-Built-InFunctions.md index 5d705687..ea5203f2 100644 --- a/docs/specs/0012-Built-InFunctions.md +++ b/docs/specs/0012-Built-InFunctions.md @@ -235,6 +235,29 @@ All three desugar to the same call. Rules: - **UFCS (`x.f(args)`)** rewrites to `f(x, args)`. **Parens are required** to disambiguate from field access — `x.f` always means field access, never a method call. If a record has a field named `f`, field access wins; UFCS is the fallback. - **Direct call** is ordinary function application. +For dotted calls, the receiver's resolved type determines the choice. A +declared field named `f` is selected even when a free function with that name +is in scope. The field value must be callable; a non-callable field is an +error and does not enable fallback. Calling the field passes only the written +arguments. UFCS passes the receiver first, followed by the written arguments, +and is considered only when the receiver has no such field. + +This rule also applies inside generic functions. If the receiver is still a +type variable when the body is checked, selection remains deferred and is +resolved for each instantiation. For example, `dispatch(x:T) = x.m()` may +select a record's `m` field for one call and a free `m(x)` for a scalar call. +The receiver, argument, result, and callback type constraints remain linked +through generalization and instantiation. An annotation cannot be required +solely to compensate for losing those links. + +Written type arguments apply to the selected callable's declaration binders. +A function-valued field has no declaration binders, so `record.f()` is +rejected even if an in-scope free `f` declares a type parameter. The selected +callable also determines the call's effect requirements: an ignored free +function contributes none, and selecting a field cannot discard its effects. +Evaluation of the receiver and written argument expressions still contributes +their own effects exactly once. + Multi-argument functions in this spec are documented subject-first (e.g. `split(s: string, separator: string)`) so all three forms work uniformly. ### Inspection (total) — [BUILTIN-STRING-INSPECTION] diff --git a/docs/specs/0017-AlgebraicEffects.md b/docs/specs/0017-AlgebraicEffects.md index 25f3fdac..a2448991 100644 --- a/docs/specs/0017-AlgebraicEffects.md +++ b/docs/specs/0017-AlgebraicEffects.md @@ -85,6 +85,13 @@ key. ## Effectful Function Types +`[EFFECTS-GENERIC-ROWS]` A written effect-row argument list must contain exactly +the effect's declared number of type arguments. Omitting the entire list leaves +the instance to inference. An explicit list cannot omit some arguments or add +extra ones, even when the function body performs no operations. Each argument +must name a known type or an enclosing type parameter; nested constructors must +have their declared arity, and a type parameter cannot itself take arguments. + An effect row follows the return type. It contains one effect reference or a bracketed list; generic references may include type arguments. @@ -126,6 +133,23 @@ discharge the operation they cover. Constructing a lambda is pure, but invoking it contributes its latent requirements; constructing one inside a handler does not give it authority after it escapes that handler's lexical region. +Passing a callback without invoking it contributes no latent requirements. +Invoking a function parameter substitutes both the actual callee and its +supplied arguments: forwarding an effectful callback through another function +preserves the effects of each invocation, including named and curried calls. +When a callback returns a record or another callable, subsequent field reads +and calls retain the returned value's effect requirements. This applies equally +when the callback is a named function, a local binding, or a function parameter; +transport through a generic helper cannot make an effectful field pure. +The same rule applies to operation results supplied by an active handler. +Returning a record or closure from a handler does not discharge effects that +are performed only when that value is called after the handler exits. + +Builtin callback and iterator behavior belongs to the resolved builtin binding. +A user function, local binding, or parameter that shadows a builtin name uses +its own body and return value for effect analysis. Its spelling cannot cause +builtin callback invocation or prove that its result has no callable fields. + The current compiler realizes these rules with a closed-program operation summary and fixed-point call analysis. Explicit open effect-row variables are not surface syntax and effect rows are not yet exposed as independently diff --git a/docs/specs/0023-LanguageFlavors.md b/docs/specs/0023-LanguageFlavors.md index 858dc485..d730f38f 100644 --- a/docs/specs/0023-LanguageFlavors.md +++ b/docs/specs/0023-LanguageFlavors.md @@ -17,6 +17,12 @@ Type inference, effect checking, project resolution, and code generation must not branch on `Flavor`. `Parsed.flavor` is retained for frontend and editor presentation only. +Dotted calls that may use UFCS retain that choice in the canonical AST until +shared type resolution selects a field or free function. A generic receiver +defers selection to each instantiation. ML field application denotes field +access directly. When both select the same field, the shared lowering uses +the same call semantics and ABI; no backend branch inspects the source flavor. + ## Supported Flavors | Flavor | Blocks | Calls | Function default | Extension | @@ -170,3 +176,9 @@ equal flat twins, and the expected unequal curried/flat pair. paired `.osp` and `.ospml` examples and requires byte-identical LLVM IR. Each ML example has a Default twin and shares its expected-output file, except for the explicit ML-only allowlist in that test. + +Twins must express the same typing contract. A helper explicitly constrained +to `Source` is not the twin of an unannotated helper that generalizes +over records with the required field. The paired sources must agree on that +constraint or both retain the generic helper. Equal output for the particular +values in one run does not establish that their inferred contracts agree. From 38098b7f73f3bd744454d15952475424489632ab Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Thu, 10 Sep 2026 18:14:20 +1000 Subject: [PATCH 10/10] Finish generics regression fixes and consolidate compiler traversals --- .claude/skills/code-dedup/SKILL.md | 123 ++--- .vscode/settings.json | 2 +- Cargo.toml | 7 + Makefile | 17 +- compiler/runtime/test_cmake_integration.sh | 60 --- compiler/runtime/test_http_runtime.sh | 80 --- crates/osprey-ast/src/doc.rs | 9 +- crates/osprey-ast/src/freevars.rs | 110 +--- crates/osprey-ast/src/lib.rs | 2 +- crates/osprey-ast/src/multiplicity.rs | 8 +- crates/osprey-ast/src/resume.rs | 155 +----- crates/osprey-ast/src/resume_tests.rs | 182 +++---- crates/osprey-ast/src/visit.rs | 153 +++--- crates/osprey-cli/src/android.rs | 23 +- crates/osprey-cli/src/docs.rs | 2 +- crates/osprey-cli/src/fmt.rs | 2 +- crates/osprey-cli/src/ios.rs | 18 +- crates/osprey-cli/src/ios_abi_tests.rs | 27 +- crates/osprey-cli/src/main.rs | 82 ++- crates/osprey-cli/src/toolchain.rs | 11 + crates/osprey-cli/src/wasm.rs | 23 +- crates/osprey-cli/tests/cli_e2e.rs | 51 +- crates/osprey-cli/tests/common/mod.rs | 10 +- crates/osprey-cli/tests/common/staging.rs | 6 +- crates/osprey-cli/tests/staged_effects.rs | 8 +- crates/osprey-codegen/src/aggregate.rs | 41 +- crates/osprey-codegen/src/builder.rs | 110 ++-- crates/osprey-codegen/src/call.rs | 3 +- crates/osprey-codegen/src/cast.rs | 3 +- crates/osprey-codegen/src/collections.rs | 27 +- crates/osprey-codegen/src/effects.rs | 198 ++----- crates/osprey-codegen/src/expr.rs | 89 +++- crates/osprey-codegen/src/fiber.rs | 6 +- crates/osprey-codegen/src/gpu.rs | 3 +- crates/osprey-codegen/src/gpu_kernel.rs | 2 +- crates/osprey-codegen/src/iter.rs | 8 +- crates/osprey-codegen/src/lib.rs | 343 +++++++++---- crates/osprey-codegen/src/listlit.rs | 47 +- crates/osprey-codegen/src/llty.rs | 2 +- crates/osprey-codegen/src/loops.rs | 9 +- crates/osprey-codegen/src/lower.rs | 15 +- crates/osprey-codegen/src/pattern.rs | 26 +- crates/osprey-codegen/src/result.rs | 41 +- crates/osprey-codegen/src/runtime.rs | 33 +- crates/osprey-codegen/src/stmt.rs | 2 +- crates/osprey-codegen/src/strings.rs | 39 +- crates/osprey-codegen/src/types.rs | 10 +- crates/osprey-lsp/src/analysis.rs | 177 +------ crates/osprey-lsp/src/diagnostics.rs | 123 ++++- crates/osprey-lsp/src/engine.rs | 20 +- crates/osprey-lsp/src/features.rs | 9 +- crates/osprey-lsp/src/hover.rs | 49 +- crates/osprey-lsp/src/inferred_views.rs | 15 +- crates/osprey-lsp/src/lib.rs | 5 + crates/osprey-lsp/src/server.rs | 89 ++-- crates/osprey-lsp/src/test_support.rs | 30 ++ crates/osprey-lsp/src/testing.rs | 4 +- crates/osprey-profiler/src/lib.rs | 3 + crates/osprey-profiler/src/report.rs | 18 +- crates/osprey-profiler/src/symbolize/mod.rs | 90 ++-- crates/osprey-project/src/imports.rs | 8 +- crates/osprey-project/src/model.rs | 12 +- crates/osprey-project/src/name_resolve.rs | 11 +- crates/osprey-project/src/resolve.rs | 9 +- crates/osprey-project/src/rewrite.rs | 13 +- crates/osprey-project/src/type_rewrite.rs | 11 +- crates/osprey-syntax/src/default/expr.rs | 21 +- crates/osprey-syntax/src/default/lower.rs | 39 +- crates/osprey-syntax/src/lib.rs | 18 +- crates/osprey-syntax/src/ml/lower.rs | 32 +- crates/osprey-syntax/src/ml/parser.rs | 33 +- crates/osprey-syntax/src/test_support.rs | 30 ++ crates/osprey-syntax/tests/ml_elegance.rs | 4 +- crates/osprey-types/src/applications.rs | 41 +- crates/osprey-types/src/builtin_docs.rs | 16 +- crates/osprey-types/src/builtins.rs | 6 +- crates/osprey-types/src/check.rs | 19 +- crates/osprey-types/src/convert.rs | 8 +- crates/osprey-types/src/ctx.rs | 22 +- crates/osprey-types/src/effect_rows.rs | 351 +++++++------ .../src/effect_rows_transport_tests.rs | 433 ++++++++++++++++ crates/osprey-types/src/env.rs | 50 +- crates/osprey-types/src/expr.rs | 146 +++--- .../osprey-types/src/generic_effects_tests.rs | 343 ++++--------- .../src/generics_apply_ml_tests.rs | 316 +++--------- .../osprey-types/src/generics_apply_tests.rs | 484 +++++------------- .../osprey-types/src/generics_decl_tests.rs | 341 ++++-------- .../src/generics_variance_assign_tests.rs | 202 +++----- .../src/generics_variance_builtin_tests.rs | 143 ++---- .../src/generics_variance_shape_tests.rs | 131 ++--- .../src/generics_variance_tests.rs | 290 +++-------- crates/osprey-types/src/lib.rs | 5 + crates/osprey-types/src/methods.rs | 160 +++++- crates/osprey-types/src/pattern.rs | 68 +-- crates/osprey-types/src/redundant_tests.rs | 11 +- crates/osprey-types/src/testutil.rs | 80 ++- crates/osprey-types/src/unify.rs | 4 +- crates/run_test_corpus.sh | 10 +- crates/testkit.rs | 17 + docs/plans/0015-generics-and-variance.md | 399 ++------------- docs/plans/0024-staged-effects.md | 8 +- docs/plans/README.md | 1 + docs/specs/0003-Syntax.md | 4 +- docs/specs/0004-TypeSystem.md | 8 +- docs/specs/0005-FunctionCalls.md | 21 +- ...el_element_type_lost_in_generic_field.ospo | 12 - ..._lost_in_generic_field.ospo.expectedoutput | 1 - .../ffi_capturing_callback.ospo | 2 +- ...ffi_capturing_callback.ospo.expectedoutput | 2 +- .../function_typed_record_field.ospo | 8 +- ...ion_typed_record_field.ospo.expectedoutput | 1 - .../ml_turbofish_no_declared_binder.ospo | 1 + ...ish_no_declared_binder.ospo.expectedoutput | 2 +- .../ml_turbofish_type_arg_arity.ospo | 1 + ...rbofish_type_arg_arity.ospo.expectedoutput | 2 +- ...variance_covariant_no_inward_coercion.ospo | 1 + .../recursive_generic_needs_annotation.ospo | 11 - ...neric_needs_annotation.ospo.expectedoutput | 1 - ...ntiated_dynamic_effect.ospo.expectedoutput | 2 +- .../staged_static_arm_requires_dynamic.ospo | 5 +- .../ufcs_field_collision.ospo.expectedoutput | 2 +- ...ant_no_inward_coercion.ospo.expectedoutput | 2 +- .../variance_in_under_two_flips.ospo | 10 + ...nce_in_under_two_flips.ospo.expectedoutput | 1 + scripts/install-deslop.sh | 18 +- scripts/verify-no-dead-code.mjs | 226 ++++++++ tests/WASM_UNPORTABLE.txt | 1 + .../injection/storage_injection.test.osp | 10 +- .../injection/storage_injection.test.ospml | 30 +- ...nel_element_type_in_generic_field.test.osp | 22 + ...e_in_generic_field.test.osp.expectedoutput | 4 + .../recursive_generic_specialization.test.osp | 24 + ...ric_specialization.test.osp.expectedoutput | 4 + .../type_equality_comprehensive.test.osp | 10 +- .../type_equality_comprehensive.test.ospml | 8 +- tree-sitter-osprey/test/corpus/osprey.txt | 2 +- vscode-extension/client/src/extension.ts | 2 +- vscode-extension/run-tests.sh | 78 --- vscode-extension/test/suite/debug.e2e.test.ts | 6 +- vscode-extension/tsconfig.json | 2 + website/start-dev.sh | 51 -- 141 files changed, 3472 insertions(+), 4332 deletions(-) delete mode 100755 compiler/runtime/test_cmake_integration.sh delete mode 100755 compiler/runtime/test_http_runtime.sh create mode 100644 crates/osprey-lsp/src/test_support.rs create mode 100644 crates/osprey-types/src/effect_rows_transport_tests.rs create mode 100644 crates/testkit.rs delete mode 100644 examples/failscompilation/channel_element_type_lost_in_generic_field.ospo delete mode 100644 examples/failscompilation/channel_element_type_lost_in_generic_field.ospo.expectedoutput delete mode 100644 examples/failscompilation/recursive_generic_needs_annotation.ospo delete mode 100644 examples/failscompilation/recursive_generic_needs_annotation.ospo.expectedoutput create mode 100644 examples/failscompilation/variance_in_under_two_flips.ospo create mode 100644 examples/failscompilation/variance_in_under_two_flips.ospo.expectedoutput create mode 100644 scripts/verify-no-dead-code.mjs create mode 100644 tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp create mode 100644 tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp.expectedoutput create mode 100644 tests/regressions/basics/types/recursive_generic_specialization.test.osp create mode 100644 tests/regressions/basics/types/recursive_generic_specialization.test.osp.expectedoutput delete mode 100755 vscode-extension/run-tests.sh delete mode 100644 website/start-dev.sh diff --git a/.claude/skills/code-dedup/SKILL.md b/.claude/skills/code-dedup/SKILL.md index 2032a9b6..f2a05bcf 100644 --- a/.claude/skills/code-dedup/SKILL.md +++ b/.claude/skills/code-dedup/SKILL.md @@ -1,109 +1,70 @@ --- name: code-dedup -description: Searches for duplicate code, duplicate tests, and dead code, then safely merges or removes them. Use when the user says "deduplicate", "find duplicates", "remove dead code", "DRY up", or "code dedup". Requires test coverage — refuses to touch untested code. +description: Finds duplicated code and dead code with deslop, then merges or removes the worst of it. Use when the user says "deduplicate", "find duplicates", "remove dead code", "DRY up", or "code dedup". --- # Code Dedup -Carefully search for duplicate code, duplicate tests, and dead code across the repo. Merge duplicates and delete dead code — but only when test coverage proves the change is safe. +Find duplication with **deslop**, then use judgement to merge only what is worth merging. -## Prerequisites — hard gate +## Judgement first -Before touching ANY code, verify these conditions. If any fail, stop and report why. +Deslop measures structural repetition. It cannot tell whether collapsing two blocks makes the code better or worse. **You decide.** A report with 476 clusters does not mean 476 edits — it means the five or ten that matter. `merge-plan` returns verdict `ai_or_human` for anything non-mechanical: that is the tool handing you the call. -1. Run `make test` — all tests must pass. If tests fail, stop. Do not dedup a broken codebase. -2. Run `make test` — tests are fail-fast AND enforce the coverage threshold from `coverage-thresholds.json`. If anything fails, stop and fix it before deduping. -3. Verify the project uses **static typing**: - - Rust (crates/, tree-sitter-osprey/): typed by default — proceed - - TypeScript (vscode-extension/, webcompiler/, website/): check `tsconfig.json` has `"strict": true` — proceed if yes - - C (compiler/runtime/): typed by default — proceed +**Merge** real copy-pasted logic — a block differing only in a symbol or a literal, 3+ near-identical call sites, one algorithm restated in two modules. -## Steps +**Leave** anything else, especially: -Copy this checklist and track progress: +- **Data, not logic** — constant tables, per-platform SDK/triple/runtime arms, doc rows. Merging buries the values the reader came for. +- **Structural coincidence** — `structural_only` CST walks and `match` shapes: same skeleton, different meaning. +- **Already factored** — only thin wrappers remain over a real helper. +- **Merges needing a new bool/enum parameter** to make one function do two jobs. -``` -Dedup Progress: -- [ ] Step 1: Prerequisites passed (tests green, coverage met, typed) -- [ ] Step 2: Dead code scan complete -- [ ] Step 3: Duplicate code scan complete -- [ ] Step 4: Duplicate test scan complete -- [ ] Step 5: Changes applied -- [ ] Step 6: Verification passed (tests green, coverage stable) -``` - -### Step 1 — Inventory test coverage - -Before deciding what to touch, understand what is tested. - -1. Run `make test` to confirm green baseline. `make test` is fail-fast AND enforces the coverage threshold from `coverage-thresholds.json` (REPO-STANDARDS-SPEC [TEST-RULES], [COVERAGE-THRESHOLDS-JSON]). It exits non-zero on any test failure OR coverage shortfall. -2. Note the current coverage percentage — this is the floor. It must not drop. -3. Identify which files/modules have coverage and which do not. Only files WITH coverage are candidates for dedup. +A wrong merge is worse than a duplicate. -### Step 2 — Scan for dead code +## Tools -Search for code that is never called, never imported, never referenced. +Prefer the MCP — live index, no rescan cost: -1. Look for unused exports, unused functions, unused variables -2. Use language-appropriate tools: - - Rust: `dead_code`/`unused_*` are denied workspace-wide, so `cargo clippy --all-targets` reports unused code as errors - - TypeScript: check for `noUnusedLocals`/`noUnusedParameters` in tsconfig, look for unexported functions with zero references - - C: compiler warnings for unused functions/variables (already caught by `-Wall -Wextra`) -3. For each candidate: **grep the entire codebase** for references (including tests, scripts, configs). Only mark as dead if truly zero references. -4. List all dead code found with file paths and line numbers. Do NOT delete yet. +| Tool | Use | +|---|---| +| `mcp__deslop__duplicates` | **Start here.** Clusters worst-first by `mass`. `{detail:"summary", limit:20}`; `include_per_file:true` for a per-file table, `path_contains` to scope. | +| `mcp__deslop__cluster-by-id` | Every occurrence path + byte range for one `id`. | +| `mcp__deslop__compare-pair` | The **only** pair evidence: two `{path,start_byte,end_byte}` in, `text_identity` and `structural` out. | +| `mcp__deslop__merge-plan` | Mechanical plan for a cluster. `ai_or_human` → hand-edit. | +| `mcp__deslop__find-similar` | Call **before writing new code** (CLAUDE.md mandates it). | +| `mcp__deslop__rescan` | Refresh after edits. | -### Step 3 — Scan for duplicate code +A cluster's `kind` is the *weakest* pair against the canonical — **never assume two members match each other**. `compare-pair` the exact ranges you intend to merge. -Search for code blocks that do the same thing in multiple places. +No MCP? Use the installed CLI — what `make _deslop` runs: -1. Look for functions/methods with identical or near-identical logic -2. Look for copy-pasted blocks (same structure, maybe different variable names) -3. Look for multiple implementations of the same algorithm or pattern -4. Check across module boundaries — duplicates often hide in different packages -5. For each duplicate pair: note both locations, what they do, and how they differ (if at all) -6. List all duplicates found. Do NOT merge yet. - -### Step 4 — Scan for duplicate tests - -Search for tests that verify the same behavior. - -1. Look for test functions with identical assertions against the same code paths -2. Look for test fixtures/helpers that are duplicated across test files -3. Look for integration tests that fully cover what a unit test also covers -4. List all duplicate tests found. Do NOT delete yet. - -### Step 5 — Apply changes (one at a time) +```bash +deslop . --nohtml --nojson --output "$PWD/target/deslop-report" --log-to-console --log-level error --no-color +``` -For each change, follow this cycle: **change → test → verify coverage → continue or revert**. +Exit `3` means over the ceiling in `.deslop.toml`. Check `deslop --version`; install from only if the binary is missing, matching the version pinned in `.github/workflows/ci.yml`. Never upgrade to move a number — the MCP server (`tool_version: 0.0.0-dev`) and the pinned CLI disagree, so **find** with the MCP and **measure** with `make _deslop`. -#### 5a. Remove dead code -- Delete dead code identified in Step 2 -- After each deletion: run `make test` (fail-fast + coverage + threshold all in one) -- If `make test` exits non-zero (test failure OR coverage drop): **revert immediately** and investigate +## The ratchet -#### 5b. Merge duplicate code -- For each duplicate pair: extract the shared logic into a single function/module -- Update all call sites to use the shared version -- After each merge: run `make test` -- If tests fail: **revert immediately** +**CI must never allow duplication to increase.** `max_duplication_percent` is a ratchet, not a budget. -#### 5c. Remove duplicate tests -- Delete the redundant test (keep the more thorough one) -- After each deletion: run `make test` -- If coverage drops below threshold, `make test` exits non-zero — **revert immediately** +- **Never raise it.** Over the ceiling means you added duplication — remove it. The number is not the thing to edit. +- **Lower it after every round** to the fresh `make _deslop` measurement. Slack above the measurement lets the next clone land free. +- **A branch may not measure above `main`** — compare with the *same* CLI version, or the version gap alone will convict or exonerate falsely. +- `.deslop.toml`'s comment block records the ratchet history. Extend it when you lower the ceiling; if that history and the live value disagree, someone raised it — **report a gate violation**. -### Step 6 — Final verification +## Process -1. Run `make lint` — all linters must pass -2. Run `make test` — tests must pass AND coverage must remain ≥ the baseline from Step 1 -3. Report: what was removed, what was merged, final coverage vs baseline +- **Baseline.** `make _deslop` — record the percentage you start from. +- **Gather.** `mcp__deslop__duplicates`, worst first. `cargo clippy --all-targets --all-features` is the whole dead-code scan (`dead_code`/`unused_*` are denied workspace-wide); grep the repo before deleting anything it flags. +- **Triage.** Apply the judgement above. Record each keeper's two locations and intended helper, and each rejection's reason so nobody re-litigates it. `.deslop.toml` scopes the gate *by path*, so inline `#[cfg(test)]` and `#[path = "…"]` modules still inflate the number — an artifact, not a task. +- **Apply.** One merge at a time, smallest diff that removes the duplication. Keep public and `pub(crate)` signatures intact so no caller has to change. +- **Verify.** `make lint`, then `make _deslop`. Report what merged, what you left and why, and duplication vs baseline. ## Rules -- **No test coverage = do not touch.** If a file has no tests covering it, leave it alone entirely. -- **Coverage must not drop.** The coverage floor from Step 1 is sacred. -- **One change at a time.** Make one dedup change, run tests, verify coverage. -- **When in doubt, leave it.** If two code blocks look similar but you're not 100% sure they're functionally identical, leave both. -- **Preserve public API surface.** Do not change function signatures or exported names. -- **Three similar lines is fine.** Only dedup when the shared logic is substantial (>10 lines) or when there are 3+ copies. +- **Three similar lines is fine** — merge at >10 shared lines or 3+ copies. +- **Edit in place.** Never leave a parallel version of anything behind. +- **When in doubt, leave it.** diff --git a/.vscode/settings.json b/.vscode/settings.json index 57449b1a..33efe241 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -30,7 +30,7 @@ "rust-analyzer.check.allTargets": true, "basilisk.enabled": true, "basilisk.uv.enabled": true, - "deslop.topOffenders.groupBy": "type", + "deslop.topOffenders.groupBy": "kind", "deslop.embedding.provider": "ollama", "deslop.embedding.model": "nomic-embed-text", "deslop.embedding.mode": "auto" diff --git a/Cargo.toml b/Cargo.toml index 86fa01f5..bdfbabd0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -67,6 +67,13 @@ unused_variables = "deny" unused_mut = "deny" unused_assignments = "deny" unused_results = "deny" +# A `pub` item not reachable from the crate root is invisible outside the crate, +# so `dead_code` never evaluates it and it can rot forever. Forcing `pub(crate)` +# puts every such item back under the dead-code lint. [LINTS-DEADCODE-REACH] +unreachable_pub = "deny" +unused_lifetimes = "deny" +unused_macro_rules = "deny" +unused_qualifications = "deny" trivial_casts = "deny" trivial_numeric_casts = "deny" elided_lifetimes_in_paths = "deny" diff --git a/Makefile b/Makefile index 4e544dda..db9cf423 100644 --- a/Makefile +++ b/Makefile @@ -279,6 +279,7 @@ lint: _deslop _lint _lint: $(EXT_NODE_DEPS) @echo "==> Linting..." node scripts/verify-node-deps-guard.mjs + node scripts/verify-no-dead-code.mjs cargo fmt --all --check cargo clippy --workspace --all-targets -- -D warnings cd $(EXT_DIR) && npm run lint @@ -288,6 +289,12 @@ _lint: $(EXT_NODE_DEPS) # threshold live in that committed config — the single source of truth. When # the `deslop` binary is absent this target FAILS: a gate that cannot run must # not report success. CI enforces the same ceiling through the official action. +# Version of the deslop CLI `make setup` installs. MUST equal the `version:` the +# Deslop action pins in .github/workflows/ci.yml — deslop measures source text, +# so a different build can report a different percentage for the SAME tree, and +# a local gate that disagrees with the merge gate is worse than no local gate. +DESLOP_VERSION ?= 0.27.0 + _deslop: @echo "==> Duplication gate (deslop)..." @if ! command -v deslop >/dev/null 2>&1; then \ @@ -301,7 +308,14 @@ _deslop: deslop . --nohtml --nojson --output $(CURDIR)/target/deslop-report --log-to-console --log-level error --no-color ## hawk: Dead-code gate (astral-sh/hawk). Fails the build when any `pub` -## declaration is unreachable from the osprey binary (hawk::dead_public). Scoped +## declaration is unreachable from the osprey binary (hawk::dead_public). +## +## hawk counts the workspace's TEST binaries as reachability roots, so an item +## whose only callers are its own `#[cfg(test)]` module passes this gate — that +## is how `osprey_debug::DebugBuild` and `osprey_syntax::dependency_sets` lived +## in the tree. `scripts/verify-no-dead-code.mjs` (run by `_lint`) answers the +## narrower question "does PRODUCT code name this?" and catches that class. +## Neither gate subsumes the other; both run. Scoped ## to dead_public ONLY — unnecessary_public / restricted-visibility findings are ## over-exposure, not dead code, and several are irreducibly public for the ## integration tests under this workspace's `dead_code = "deny"` policy, so they @@ -407,6 +421,7 @@ setup: $(EXT_NODE_DEPS) $(WEBCOMPILER_NODE_DEPS) $(WEBSITE_NODE_DEPS) @echo "==> Setting up development environment..." rustup component add rustfmt clippy llvm-tools-preview command -v cargo-llvm-cov >/dev/null 2>&1 || cargo install cargo-llvm-cov + command -v deslop >/dev/null 2>&1 || DESLOP_VERSION=$(DESLOP_VERSION) bash scripts/install-deslop.sh @echo "==> Setup complete. Run 'make ci' to validate." # --------------------------------------------------------------------------- diff --git a/compiler/runtime/test_cmake_integration.sh b/compiler/runtime/test_cmake_integration.sh deleted file mode 100755 index 8f4052d0..00000000 --- a/compiler/runtime/test_cmake_integration.sh +++ /dev/null @@ -1,60 +0,0 @@ -#!/bin/bash - -echo "🔧 CMake C Test Integration Verification" -echo "=========================================" -echo "⚠️ This script must be run inside the VS Code Dev Container" -echo " Use Command Palette → 'Dev Containers: Rebuild Container'" -echo "" - -# Navigate to runtime directory -cd "$(dirname "$0")" - -# Clean and create build directory -echo "📁 Setting up build directory..." -rm -rf build -mkdir -p build -cd build - -# Configure with CMake -echo "⚙️ Configuring CMake..." -cmake .. -DCMAKE_BUILD_TYPE=Debug - -if [ $? -ne 0 ]; then - echo "❌ CMake configuration failed!" - exit 1 -fi - -echo "✅ CMake configuration successful!" - -# Build the tests -echo "🔨 Building C runtime tests..." -make -j$(nproc) - -if [ $? -ne 0 ]; then - echo "❌ Build failed!" - exit 1 -fi - -echo "✅ Build successful!" - -# List available tests -echo "📋 Available CTest tests:" -ctest --show-only=json-v1 | jq -r '.tests[].name' 2>/dev/null || ctest -N - -# Run tests with CTest -echo "🧪 Running CTest..." -ctest --verbose - -if [ $? -eq 0 ]; then - echo "✅ All C runtime tests passed!" - echo "" - echo "🎉 VS Code Integration Ready!" - echo " - Open this project in VS Code with Dev Container" - echo " - Go to Test Explorer (flask icon in sidebar)" - echo " - You should see 'SystemRuntimeTests' and 'FiberRuntimeTests'" - echo " - Click the play button to run individual tests" - echo " - Use debug button to debug tests with breakpoints" -else - echo "❌ Some tests failed!" - exit 1 -fi \ No newline at end of file diff --git a/compiler/runtime/test_http_runtime.sh b/compiler/runtime/test_http_runtime.sh deleted file mode 100755 index f50d112f..00000000 --- a/compiler/runtime/test_http_runtime.sh +++ /dev/null @@ -1,80 +0,0 @@ -#!/bin/bash - -# Test script for HTTP runtime -echo "🧪 Compiling and testing HTTP runtime..." - -# Compile all the runtime modules and tests -echo "📦 Compiling runtime modules..." - -# Detect OpenSSL paths cross-platform -OPENSSL_CFLAGS="" -OPENSSL_LDFLAGS="-lssl -lcrypto" - -# Try to find OpenSSL include/lib directories -if [ "$(uname)" = "Darwin" ]; then - # macOS with Homebrew - for path in "/opt/homebrew/opt/openssl@3" "/usr/local/opt/openssl@3" "/opt/homebrew/opt/openssl" "/usr/local/opt/openssl"; do - if [ -d "$path" ]; then - OPENSSL_CFLAGS="-I${path}/include" - OPENSSL_LDFLAGS="-L${path}/lib -lssl -lcrypto" - break - fi - done -elif [ "$(uname)" = "Linux" ]; then - # Linux - usually in standard locations - if pkg-config --exists openssl 2>/dev/null; then - OPENSSL_CFLAGS="$(pkg-config --cflags openssl)" - OPENSSL_LDFLAGS="$(pkg-config --libs openssl)" - fi -fi - -gcc -c http_shared.c -o http_shared.o -pthread $OPENSSL_CFLAGS -gcc -c http_client_runtime.c -o http_client_runtime.o -pthread $OPENSSL_CFLAGS -gcc -c http_server_request.c -o http_server_request.o -pthread $OPENSSL_CFLAGS -gcc -c http_server_response.c -o http_server_response.o -pthread $OPENSSL_CFLAGS -gcc -c http_server_runtime.c -o http_server_runtime.o -pthread $OPENSSL_CFLAGS -gcc -c websocket_client_runtime.c -o websocket_client_runtime.o -pthread $OPENSSL_CFLAGS -gcc -c websocket_server_runtime.c -o websocket_server_runtime.o -pthread $OPENSSL_CFLAGS - -if [ $? -ne 0 ]; then - echo "❌ Runtime compilation failed!" - exit 1 -fi - -echo "🧪 Compiling test suite..." -gcc -o test_http_runtime http_runtime_tests.c \ - http_shared.o \ - http_client_runtime.o \ - http_server_request.o \ - http_server_response.o \ - http_server_runtime.o \ - websocket_client_runtime.o \ - websocket_server_runtime.o \ - -L/usr/local/lib -lfiber_runtime \ - -pthread $OPENSSL_CFLAGS $OPENSSL_LDFLAGS - -if [ $? -ne 0 ]; then - echo "❌ Test compilation failed!" - exit 1 -fi - -echo "✅ Compilation successful!" -echo "" - -# Run the tests -echo "🚀 Running HTTP runtime tests..." -echo "" -./test_http_runtime - -if [ $? -ne 0 ]; then - echo "❌ Tests failed!" - exit 1 -fi - -echo "" -echo "🎉 All tests passed! HTTP runtime is working correctly." - -# Clean up -rm -f *.o test_http_runtime - -echo "✅ Test cleanup complete." diff --git a/crates/osprey-ast/src/doc.rs b/crates/osprey-ast/src/doc.rs index 71add3bb..cdf16816 100644 --- a/crates/osprey-ast/src/doc.rs +++ b/crates/osprey-ast/src/doc.rs @@ -83,13 +83,6 @@ impl DocComment { } } - /// A summary-only outer doc — the common case, and the shape a bare doc - /// comment with no recognised sections lowers to. - #[must_use] - pub fn summary_only(summary: impl Into) -> DocComment { - Self::new(summary, String::new(), DocScope::Outer) - } - /// Render the whole doc comment as the Markdown block a hover shows: the /// summary, the body, then each populated section as a heading. `[Symbol]` /// links are preserved verbatim so the LSP client renders them as links. @@ -170,7 +163,7 @@ mod tests { #[test] fn summary_only_leaves_every_section_empty() { // [DOC-MODEL] a summary-only comment has the canonical empty-field shape. - let doc = DocComment::summary_only("Adds two ints."); + let doc = DocComment::new("Adds two ints.", String::new(), DocScope::Outer); assert_eq!(doc.summary, "Adds two ints."); assert!(doc.body.is_empty()); assert!(doc.params.is_empty() && doc.returns.is_none()); diff --git a/crates/osprey-ast/src/freevars.rs b/crates/osprey-ast/src/freevars.rs index 0405bca3..ebf202f9 100644 --- a/crates/osprey-ast/src/freevars.rs +++ b/crates/osprey-ast/src/freevars.rs @@ -6,7 +6,7 @@ //! parameters, `let`s in blocks, `match`/`select`/handler pattern bindings) //! are subtracted; everything else referenced is free. -use crate::{Expr, InterpolatedPart, MatchArm, Pattern, Stmt}; +use crate::{AstNode, Expr, MatchArm, Pattern, Stmt}; use std::collections::BTreeSet; /// Collect the free identifiers of `e` into `out` (sorted, deduplicated). @@ -36,63 +36,8 @@ fn scoped( fn walk(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { match e { - Expr::Integer(_) | Expr::Float(_) | Expr::Str(_) | Expr::Bool(_) => {} - Expr::Identifier(n) => note(n, bound, out), + Expr::Identifier(name) => note(name, bound, out), Expr::Path(path) => note(&path.to_string(), bound, out), - Expr::InterpolatedStr(parts) => { - for p in parts { - if let InterpolatedPart::Expr(inner) = p { - walk(inner, bound, out); - } - } - } - Expr::List(xs, _) => walk_slice(xs, bound, out, |x| x), - Expr::Map(entries) => { - for en in entries { - walk(&en.key, bound, out); - walk(&en.value, bound, out); - } - } - Expr::Object(fields) => walk_slice(fields, bound, out, |f| &f.value), - Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - walk(left, bound, out); - walk(right, bound, out); - } - Expr::TypeApply { - function: operand, .. - } - | Expr::Unary { operand, .. } => walk(operand, bound, out), - e2 => walk_rest(e2, bound, out), - } -} - -/// Continuation of [`walk`] (kept in thirds so each stays small). -fn walk_rest(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { - match e { - Expr::Call { - function, - arguments, - named_arguments, - } => { - walk(function, bound, out); - walk_slice(arguments, bound, out, |x| x); - walk_slice(named_arguments, bound, out, |n| &n.value); - } - Expr::MethodCall { - target, - arguments, - named_arguments, - .. - } => { - walk(target, bound, out); - walk_slice(arguments, bound, out, |x| x); - walk_slice(named_arguments, bound, out, |n| &n.value); - } - Expr::FieldAccess { target, .. } => walk(target, bound, out), - Expr::Index { target, index } => { - walk(target, bound, out); - walk(index, bound, out); - } Expr::Lambda { parameters, body, .. } => { @@ -103,52 +48,29 @@ fn walk_rest(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { walk(value, bound, out); walk_arms(arms, bound, out); } - Expr::Block { statements, value } => walk_block(statements, value.as_deref(), bound, out), - // `name { … }` where `name` is a bound local is a record UPDATE that - // reads `name` (`aggregate::gen_constructor` redirects; the parser - // cannot tell the forms apart). Noting a real type name is harmless: - // consumers filter against actual locals (captures via `cg.lookup`, - // liveness against `let`-bound ledger names). - Expr::TypeConstructor { name, fields, .. } => { - note(name, bound, out); - walk_slice(fields, bound, out, |f| &f.value); - } - Expr::Update { record, fields } => { - note(record, bound, out); - walk_slice(fields, bound, out, |f| &f.value); - } - e2 => walk_fiber(e2, bound, out), - } -} - -/// Final third of the walker: fiber/effect forms (and the leaf-handled rest). -fn walk_fiber(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { - match e { - Expr::Spawn(inner) | Expr::Await(inner) | Expr::Recv(inner) | Expr::Yield(Some(inner)) => { - walk(inner, bound, out); - } - Expr::Send { channel, value } => { - walk(channel, bound, out); - walk(value, bound, out); - } Expr::Select { arms } => walk_arms(arms, bound, out), - Expr::Perform { - arguments, - named_arguments, - .. + Expr::Block { statements, value } => walk_block(statements, value.as_deref(), bound, out), + // A constructor spelling can name a local record update. Consumers + // filter actual type names against locals; an update's base is a read. + Expr::TypeConstructor { name, fields, .. } + | Expr::Update { + record: name, + fields, } => { - walk_slice(arguments, bound, out, |x| x); - walk_slice(named_arguments, bound, out, |n| &n.value); + note(name, bound, out); + walk_slice(fields, bound, out, |field| &field.value); } - Expr::Resume(Some(value)) => walk(value, bound, out), Expr::Handler { arms, body, .. } => { for arm in arms { scoped(bound, arm.params.clone(), out, |b, o| walk(&arm.body, b, o)); } walk(body, bound, out); } - // Every other variant is fully handled by the first two thirds. - _ => {} + _ => AstNode::Expression(e).for_each_child(|child| { + if let AstNode::Expression(expression) = child { + walk(expression, bound, out); + } + }), } } diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs index c89060ad..e1c120ac 100644 --- a/crates/osprey-ast/src/lib.rs +++ b/crates/osprey-ast/src/lib.rs @@ -26,7 +26,7 @@ pub use generics::{EffectRef, TypeParam, Variance}; pub use multiplicity::{Multiplicity, OperationTable, REPLAYABLE_KEYWORD}; pub use resume::{contains_resume, resumes_on_one_path}; pub use stage::{Stage, STATIC_STAGE_KEYWORD}; -pub use visit::{walk_each, walk_program, AstVisitor}; +pub use visit::{walk_each, walk_program, AstNode, AstVisitor}; /// The one wording for an entry conflict [MODULES-ENTRYPOINT]. Two phases can /// reach it — the type checker for a plain source, the project assembler for a diff --git a/crates/osprey-ast/src/multiplicity.rs b/crates/osprey-ast/src/multiplicity.rs index 62f83faf..3b9a59bc 100644 --- a/crates/osprey-ast/src/multiplicity.rs +++ b/crates/osprey-ast/src/multiplicity.rs @@ -178,17 +178,13 @@ mod tests { statements: vec![ effect( "Choice", - crate::Stage::Dynamic, + Stage::Dynamic, vec![ operation("pick", Some(Multiplicity::Many), false), operation("seed", None, true), ], ), - effect( - "Tile", - crate::Stage::Static, - vec![operation("size", None, false)], - ), + effect("Tile", Stage::Static, vec![operation("size", None, false)]), ], }; let table = OperationTable::collect(&program); diff --git a/crates/osprey-ast/src/resume.rs b/crates/osprey-ast/src/resume.rs index 4ed96a53..3070885c 100644 --- a/crates/osprey-ast/src/resume.rs +++ b/crates/osprey-ast/src/resume.rs @@ -9,7 +9,7 @@ //! which is the affine rule multiplicity enforces. //! Implements [EFFECTS-RESUME], [MULTI-HANDLE-ONCE]. -use crate::{Expr, InterpolatedPart, Stmt}; +use crate::{AstNode, Expr, Stmt}; /// True when `e` contains a `resume` belonging to the ENCLOSING handler arm — /// a nested handler's body owns its own `resume`s, so they don't count. @@ -17,69 +17,19 @@ use crate::{Expr, InterpolatedPart, Stmt}; pub fn contains_resume(e: &Expr) -> bool { match e { Expr::Resume(_) => true, - Expr::InterpolatedStr(parts) => parts - .iter() - .any(|p| matches!(p, crate::InterpolatedPart::Expr(inner) if contains_resume(inner))), - Expr::List(xs, _) => xs.iter().any(contains_resume), - Expr::Map(entries) => entries - .iter() - .any(|entry| contains_resume(&entry.key) || contains_resume(&entry.value)), - Expr::Object(fields) - | Expr::TypeConstructor { fields, .. } - | Expr::Update { fields, .. } => fields.iter().any(|f| contains_resume(&f.value)), - Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - contains_resume(left) || contains_resume(right) - } - Expr::TypeApply { - function: operand, .. - } - | Expr::Unary { operand, .. } => contains_resume(operand), - Expr::Call { - function, - arguments, - named_arguments, - } => { - contains_resume(function) - || arguments.iter().any(contains_resume) - || named_arguments.iter().any(|n| contains_resume(&n.value)) - } - Expr::MethodCall { - target, - arguments, - named_arguments, - .. - } => { - contains_resume(target) - || arguments.iter().any(contains_resume) - || named_arguments.iter().any(|n| contains_resume(&n.value)) - } - Expr::FieldAccess { target, .. } => contains_resume(target), - Expr::Index { target, index } => contains_resume(target) || contains_resume(index), - Expr::Lambda { body, .. } | Expr::Spawn(body) | Expr::Await(body) | Expr::Recv(body) => { - contains_resume(body) - } - Expr::Yield(Some(value)) => contains_resume(value), - Expr::Send { channel, value } => contains_resume(channel) || contains_resume(value), - Expr::Match { value, arms } => { - contains_resume(value) || arms.iter().any(|arm| contains_resume(&arm.body)) - } - Expr::Block { statements, value } => { - statements.iter().any(stmt_contains_resume) - || value.as_deref().is_some_and(contains_resume) - } - Expr::Select { arms } => arms.iter().any(|arm| contains_resume(&arm.body)), - Expr::Perform { - arguments, - named_arguments, - .. - } => { - arguments.iter().any(contains_resume) - || named_arguments.iter().any(|n| contains_resume(&n.value)) - } - // A nested handler owns its own `resume`; do not mark the outer handler - // as a resuming region because of it. + // Only the handled body belongs to the enclosing arm. Expr::Handler { body, .. } => contains_resume(body), - _ => false, + _ => { + let mut found = false; + AstNode::Expression(e).for_each_child(|child| { + found = found + || match child { + AstNode::Statement(statement) => stmt_contains_resume(statement), + AstNode::Expression(expression) => contains_resume(expression), + }; + }); + found + } } } @@ -136,77 +86,14 @@ pub fn resumes_on_one_path(body: &Expr) -> u32 { /// Sum the path length of every child evaluated on the way through `body`. fn sequential_children(body: &Expr) -> u32 { - let each = |xs: &[Expr]| xs.iter().map(resumes_on_one_path).sum(); - match body { - Expr::InterpolatedStr(parts) => parts - .iter() - .map(|part| match part { - InterpolatedPart::Expr(inner) => resumes_on_one_path(inner), - InterpolatedPart::Text(_) => 0, - }) - .sum(), - Expr::List(values, _) => each(values), - Expr::Map(entries) => entries - .iter() - .map(|entry| resumes_on_one_path(&entry.key) + resumes_on_one_path(&entry.value)) - .sum(), - Expr::Object(fields) - | Expr::TypeConstructor { fields, .. } - | Expr::Update { fields, .. } => fields.iter().map(|f| resumes_on_one_path(&f.value)).sum(), - Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - resumes_on_one_path(left) + resumes_on_one_path(right) - } - Expr::TypeApply { - function: operand, .. - } - | Expr::Unary { operand, .. } => resumes_on_one_path(operand), - Expr::Call { - function, - arguments, - named_arguments, - } => { - resumes_on_one_path(function) - + each(arguments) - + named_arguments - .iter() - .map(|n| resumes_on_one_path(&n.value)) - .sum::() - } - Expr::MethodCall { - target, - arguments, - named_arguments, - .. - } => { - resumes_on_one_path(target) - + each(arguments) - + named_arguments - .iter() - .map(|n| resumes_on_one_path(&n.value)) - .sum::() - } - Expr::FieldAccess { target, .. } => resumes_on_one_path(target), - Expr::Index { target, index } => resumes_on_one_path(target) + resumes_on_one_path(index), - Expr::Spawn(inner) | Expr::Await(inner) | Expr::Recv(inner) => resumes_on_one_path(inner), - Expr::Yield(value) => value.as_deref().map_or(0, resumes_on_one_path), - Expr::Send { channel, value } => resumes_on_one_path(channel) + resumes_on_one_path(value), - Expr::Block { statements, value } => { - statements.iter().map(statement_resumes).sum::() - + value.as_deref().map_or(0, resumes_on_one_path) - } - Expr::Perform { - arguments, - named_arguments, - .. - } => { - each(arguments) - + named_arguments - .iter() - .map(|n| resumes_on_one_path(&n.value)) - .sum::() - } - _ => 0, - } + let mut total = 0; + AstNode::Expression(body).for_each_child(|child| { + total += match child { + AstNode::Statement(statement) => statement_resumes(statement), + AstNode::Expression(expression) => resumes_on_one_path(expression), + }; + }); + total } fn statement_resumes(stmt: &Stmt) -> u32 { diff --git a/crates/osprey-ast/src/resume_tests.rs b/crates/osprey-ast/src/resume_tests.rs index 216c9a72..2b59237a 100644 --- a/crates/osprey-ast/src/resume_tests.rs +++ b/crates/osprey-ast/src/resume_tests.rs @@ -33,18 +33,18 @@ fn field(value: Expr) -> crate::FieldAssignment { value, } } -fn assert_all_contain(cases: &[Expr]) { - for e in cases { - assert!(contains_resume(e), "resume not found in {e:?}"); - } -} - -#[test] -fn walks_literal_and_data_container_forms() { - assert_all_contain(&[ - Expr::InterpolatedStr(vec![crate::InterpolatedPart::Expr(r())]), +/// Every expression form that holds a sub-expression in a **container** +/// position, each built around exactly one `resume()`. The containment walk and +/// the one-path count must both cross all of them, so the list is stated once +/// here instead of once per test, where the two copies could drift apart. +fn container_forms() -> Vec { + vec![ + Expr::InterpolatedStr(vec![ + InterpolatedPart::Text("t".into()), + InterpolatedPart::Expr(r()), + ]), Expr::List(vec![r()], None), - Expr::Map(vec![crate::MapEntry { + Expr::Map(vec![MapEntry { key: r(), value: Expr::Integer(0), }]), @@ -71,16 +71,23 @@ fn walks_literal_and_data_container_forms() { op: "-".into(), operand: b(r()), }, - ]); + ] } -#[test] -fn walks_call_control_and_concurrency_forms() { - assert_all_contain(&[ +/// The call, field and concurrency forms — still one sequential path each, so +/// they too are crossed exactly once. Positional and named argument lists are +/// both listed, because they are separate positions in the walk. +fn call_forms() -> Vec { + vec![ + Expr::Call { + function: b(Expr::Identifier("f".into())), + arguments: vec![r()], + named_arguments: Vec::new(), + }, Expr::Call { function: b(Expr::Identifier("f".into())), arguments: Vec::new(), - named_arguments: vec![crate::NamedArgument { + named_arguments: vec![NamedArgument { name: "a".into(), value: r(), }], @@ -99,12 +106,6 @@ fn walks_call_control_and_concurrency_forms() { target: b(Expr::Identifier("xs".into())), index: b(r()), }, - Expr::Lambda { - parameters: Vec::new(), - return_type: None, - body: b(r()), - position: None, - }, Expr::Spawn(b(r())), Expr::Await(b(r())), Expr::Recv(b(r())), @@ -113,16 +114,6 @@ fn walks_call_control_and_concurrency_forms() { channel: b(Expr::Integer(0)), value: b(r()), }, - Expr::Match { - value: b(r()), - arms: Vec::new(), - }, - Expr::Select { - arms: vec![crate::MatchArm { - pattern: crate::Pattern::Wildcard, - body: r(), - }], - }, Expr::Perform { effect: "E".into(), operation: "o".into(), @@ -130,7 +121,45 @@ fn walks_call_control_and_concurrency_forms() { named_arguments: Vec::new(), position: None, }, - ]); + ] +} + +/// The forms whose sub-expression is NOT on one sequential path: a lambda body +/// runs later, and `match`/`select` arms are alternatives. The walk still finds +/// a `resume` inside them — the one-path count deliberately does not cross them. +fn branching_forms() -> Vec { + vec![ + Expr::Lambda { + parameters: Vec::new(), + return_type: None, + body: b(r()), + position: None, + }, + Expr::Match { + value: b(r()), + arms: Vec::new(), + }, + Expr::Select { + arms: vec![arm(r())], + }, + ] +} + +fn assert_all_contain(cases: &[Expr]) { + for e in cases { + assert!(contains_resume(e), "resume not found in {e:?}"); + } +} + +#[test] +fn walks_literal_and_data_container_forms() { + assert_all_contain(&container_forms()); +} + +#[test] +fn walks_call_control_and_concurrency_forms() { + assert_all_contain(&call_forms()); + assert_all_contain(&branching_forms()); } #[test] @@ -139,7 +168,7 @@ fn negatives_and_statement_walks() { assert!(!contains_resume(&Expr::Integer(1))); assert!(!contains_resume(&Expr::Yield(None))); let import_only = Expr::Block { - statements: vec![crate::Stmt::Import(crate::ImportDecl { + statements: vec![Stmt::Import(crate::ImportDecl { target: crate::ImportTarget { namespace: crate::NamespaceName::Identifier("m".into()), path: crate::SymbolPath::default(), @@ -153,7 +182,7 @@ fn negatives_and_statement_walks() { assert!(!contains_resume(&import_only)); // Assignment statements inside blocks are walked. let assign = Expr::Block { - statements: vec![crate::Stmt::Assignment { + statements: vec![Stmt::Assignment { name: "x".into(), value: r(), position: None, @@ -180,7 +209,7 @@ fn finds_resume_through_blocks_but_not_nested_handlers() { let nested = Expr::Handler { stage: crate::Stage::Dynamic, effect: "E".into(), - arms: vec![crate::HandlerArm { + arms: vec![HandlerArm { operation: "op".into(), params: Vec::new(), body: Expr::Resume(None), @@ -250,87 +279,10 @@ fn select_branches_and_lambdas_and_nested_handlers() { #[test] fn every_sequential_position_is_crossed() { - let cases = [ - Expr::InterpolatedStr(vec![ - InterpolatedPart::Text("t".into()), - InterpolatedPart::Expr(r()), - ]), - Expr::List(vec![r()], None), - Expr::Map(vec![MapEntry { - key: r(), - value: Expr::Integer(0), - }]), - Expr::Object(vec![field(r())]), - Expr::TypeConstructor { - name: "C".into(), - type_args: Vec::new(), - fields: vec![field(r())], - }, - Expr::Update { - record: "r".into(), - fields: vec![field(r())], - }, - Expr::Binary { - op: "+".into(), - left: b(Expr::Integer(1)), - right: b(r()), - }, - Expr::Pipe { - left: b(r()), - right: b(Expr::Identifier("f".into())), - }, - Expr::Unary { - op: "-".into(), - operand: b(r()), - }, - Expr::Call { - function: b(Expr::Identifier("f".into())), - arguments: vec![r()], - named_arguments: Vec::new(), - }, - Expr::MethodCall { - target: b(r()), - method: "m".into(), - arguments: Vec::new(), - named_arguments: Vec::new(), - }, - Expr::FieldAccess { - target: b(r()), - field: "x".into(), - }, - Expr::Index { - target: b(Expr::Identifier("xs".into())), - index: b(r()), - }, - Expr::Spawn(b(r())), - Expr::Await(b(r())), - Expr::Recv(b(r())), - Expr::Yield(Some(b(r()))), - Expr::Send { - channel: b(Expr::Integer(0)), - value: b(r()), - }, - Expr::Perform { - effect: "E".into(), - operation: "op".into(), - arguments: vec![r()], - named_arguments: Vec::new(), - position: None, - }, - ]; - for case in &cases { + for case in container_forms().iter().chain(&call_forms()) { assert_eq!(resumes_on_one_path(case), 1, "not crossed: {case:?}"); } - // Named arguments are crossed too, and a value-less `yield` crosses nothing. - let named = Expr::Call { - function: b(Expr::Identifier("f".into())), - arguments: Vec::new(), - named_arguments: vec![NamedArgument { - name: "a".into(), - value: r(), - }], - }; - assert_eq!(resumes_on_one_path(&named), 1); + // A value-less `yield` and a bare identifier cross nothing. assert_eq!(resumes_on_one_path(&Expr::Yield(None)), 0); assert_eq!(resumes_on_one_path(&Expr::Identifier("x".into())), 0); } diff --git a/crates/osprey-ast/src/visit.rs b/crates/osprey-ast/src/visit.rs index 0d8d1d5f..c22889b4 100644 --- a/crates/osprey-ast/src/visit.rs +++ b/crates/osprey-ast/src/visit.rs @@ -18,11 +18,26 @@ pub trait AstVisitor { fn expression(&mut self, _expression: &Expr) {} } -enum Node<'a> { +/// A borrowed syntax node whose immediate children can be visited in source order. +#[derive(Debug, Clone, Copy)] +pub enum AstNode<'a> { + /// A declaration or executable statement. Statement(&'a Stmt), + /// An expression, including any statements in a block. Expression(&'a Expr), } +impl AstNode<'_> { + /// Visit immediate children only. Callers retain control of recursion, + /// lexical scopes, and branch-specific combination rules. + pub fn for_each_child(self, mut visit: impl FnMut(Self)) { + match self { + Self::Statement(statement) => statement_children(statement, &mut visit), + Self::Expression(expression) => expression_children(expression, &mut visit), + } + } +} + /// Walk every statement and expression in source order without recursive /// visitor boilerplate. Implements the shared traversal required by /// [LSP-HOVER-EFFECT-OPERATIONS] and [LSP-IMPLEMENTATIONS-EFFECT-HANDLERS]. @@ -31,73 +46,70 @@ pub fn walk_program(program: &Program, visitor: &mut impl AstVisitor) { .statements .iter() .rev() - .map(Node::Statement) + .map(AstNode::Statement) .collect(); while let Some(node) = pending.pop() { match node { - Node::Statement(statement) => { - visitor.statement(statement); - push_statement_children(statement, &mut pending); - } - Node::Expression(expression) => { - visitor.expression(expression); - push_expression_children(expression, &mut pending); - } + AstNode::Statement(statement) => visitor.statement(statement), + AstNode::Expression(expression) => visitor.expression(expression), + } + let start = pending.len(); + node.for_each_child(|child| pending.push(child)); + if let Some(children) = pending.get_mut(start..) { + children.reverse(); } } } -fn push_statement_children<'a>(statement: &'a Stmt, pending: &mut Vec>) { +fn statement_children<'a>(statement: &'a Stmt, visit: &mut impl FnMut(AstNode<'a>)) { match statement { Stmt::Namespace { body, .. } => { - pending.extend(body.iter().rev().map(Node::Statement)); + for statement in body { + visit(AstNode::Statement(statement)); + } + } + Stmt::Module { body, .. } => { + for item in body { + visit(AstNode::Statement(&item.declaration)); + } } - Stmt::Module { body, .. } => pending.extend( - body.iter() - .rev() - .map(|item| Node::Statement(item.declaration.as_ref())), - ), Stmt::Let { value, .. } | Stmt::Assignment { value, .. } | Stmt::Expr { value, .. } - | Stmt::Function { body: value, .. } => pending.push(Node::Expression(value)), - Stmt::Type { variants, .. } => push_constraints(variants, pending), - Stmt::Import(_) | Stmt::Extern { .. } | Stmt::Effect { .. } | Stmt::Signature { .. } => {} - } -} - -fn push_constraints<'a>(variants: &'a [crate::TypeVariant], pending: &mut Vec>) { - for variant in variants.iter().rev() { - for field in variant.fields.iter().rev() { - if let Some(constraint) = &field.constraint { - pending.push(Node::Expression(constraint)); + | Stmt::Function { body: value, .. } => visit(AstNode::Expression(value)), + Stmt::Type { variants, .. } => { + for field in variants.iter().flat_map(|variant| &variant.fields) { + if let Some(constraint) = &field.constraint { + visit(AstNode::Expression(constraint)); + } } } + Stmt::Import(_) | Stmt::Extern { .. } | Stmt::Effect { .. } | Stmt::Signature { .. } => {} } } -fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec>) { +fn expression_children<'a>(expression: &'a Expr, visit: &mut impl FnMut(AstNode<'a>)) { match expression { Expr::InterpolatedStr(parts) => { - for part in parts.iter().rev() { + for part in parts { if let InterpolatedPart::Expr(value) = part { - pending.push(Node::Expression(value)); + visit(AstNode::Expression(value)); } } } - Expr::List(values, _) => push_each(values, pending, |value| value), + Expr::List(values, _) => visit_each(values, visit, |value| value), Expr::Map(entries) => { - for entry in entries.iter().rev() { - pending.push(Node::Expression(&entry.value)); - pending.push(Node::Expression(&entry.key)); + for entry in entries { + visit(AstNode::Expression(&entry.key)); + visit(AstNode::Expression(&entry.value)); } } Expr::Object(fields) | Expr::TypeConstructor { fields, .. } - | Expr::Update { fields, .. } => push_each(fields, pending, |field| &field.value), + | Expr::Update { fields, .. } => visit_each(fields, visit, |field| &field.value), Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - pending.push(Node::Expression(right)); - pending.push(Node::Expression(left)); + visit(AstNode::Expression(left)); + visit(AstNode::Expression(right)); } Expr::TypeApply { function: operand, .. @@ -105,63 +117,63 @@ fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec | Expr::Unary { operand, .. } | Expr::Spawn(operand) | Expr::Await(operand) - | Expr::Recv(operand) => pending.push(Node::Expression(operand)), + | Expr::Recv(operand) + | Expr::FieldAccess { + target: operand, .. + } + | Expr::Lambda { body: operand, .. } => visit(AstNode::Expression(operand)), Expr::Call { - function, + function: target, arguments, named_arguments, - } => { - push_each(named_arguments, pending, |argument| &argument.value); - push_each(arguments, pending, |argument| argument); - pending.push(Node::Expression(function)); } - Expr::MethodCall { + | Expr::MethodCall { target, arguments, named_arguments, .. } => { - push_each(named_arguments, pending, |argument| &argument.value); - push_each(arguments, pending, |argument| argument); - pending.push(Node::Expression(target)); + visit(AstNode::Expression(target)); + visit_each(arguments, visit, |argument| argument); + visit_each(named_arguments, visit, |argument| &argument.value); } - Expr::FieldAccess { target, .. } => pending.push(Node::Expression(target)), Expr::Index { target, index } => { - pending.push(Node::Expression(index)); - pending.push(Node::Expression(target)); + visit(AstNode::Expression(target)); + visit(AstNode::Expression(index)); } - Expr::Lambda { body, .. } => pending.push(Node::Expression(body)), Expr::Match { value, arms } => { - push_each(arms, pending, |arm| &arm.body); - pending.push(Node::Expression(value)); + visit(AstNode::Expression(value)); + visit_each(arms, visit, |arm| &arm.body); } Expr::Block { statements, value } => { + for statement in statements { + visit(AstNode::Statement(statement)); + } if let Some(value) = value { - pending.push(Node::Expression(value)); + visit(AstNode::Expression(value)); } - pending.extend(statements.iter().rev().map(Node::Statement)); } Expr::Yield(value) | Expr::Resume(value) => { if let Some(value) = value { - pending.push(Node::Expression(value)); + visit(AstNode::Expression(value)); } } Expr::Send { channel, value } => { - pending.push(Node::Expression(value)); - pending.push(Node::Expression(channel)); + visit(AstNode::Expression(channel)); + visit(AstNode::Expression(value)); } - Expr::Select { arms } => push_each(arms, pending, |arm| &arm.body), + Expr::Select { arms } => visit_each(arms, visit, |arm| &arm.body), Expr::Perform { arguments, named_arguments, .. } => { - push_each(named_arguments, pending, |argument| &argument.value); - push_each(arguments, pending, |argument| argument); + visit_each(arguments, visit, |argument| argument); + visit_each(named_arguments, visit, |argument| &argument.value); } Expr::Handler { arms, body, .. } => { - pending.push(Node::Expression(body)); - push_each(arms, pending, |arm| &arm.body); + visit_each(arms, visit, |arm| &arm.body); + visit(AstNode::Expression(body)); } Expr::Integer(_) | Expr::Float(_) @@ -172,17 +184,14 @@ fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec } } -fn push_each<'a, T>( +fn visit_each<'a, T>( items: &'a [T], - pending: &mut Vec>, + visit: &mut impl FnMut(AstNode<'a>), expression: impl Fn(&'a T) -> &'a Expr, ) { - pending.extend( - items - .iter() - .rev() - .map(|item| Node::Expression(expression(item))), - ); + for item in items { + visit(AstNode::Expression(expression(item))); + } } /// Recurse into every element of `items`, projecting each to its diff --git a/crates/osprey-cli/src/android.rs b/crates/osprey-cli/src/android.rs index 4263e985..eb2b95dd 100644 --- a/crates/osprey-cli/src/android.rs +++ b/crates/osprey-cli/src/android.rs @@ -43,18 +43,11 @@ impl Target { /// Unsupported options fail even when only checking a program. [ANDROID-TARGET-OPTIONS] pub(crate) fn validate(cli: &Cli) -> Result<(), ExitCode> { - if let Some(code) = crate::reject_debug_cross_target(cli) { - return Err(code); - } - if cli.memory != "default" { - return Err(fail( - "Android supports --memory=default; other runtime archives are not available", - )); - } - if cli.mode == "--run" { - return Err(fail("Android produces an app-logic library; use --compile and call it from an Android host (see examples/mobile/android/)")); - } - Ok(()) + crate::reject_cross_target_options( + cli, + "Android", + Some("an Android host (see examples/mobile/android/)"), + ) } pub(crate) fn source( @@ -73,11 +66,7 @@ pub(crate) fn build( out: &Path, target: Target, ) -> Result<(), ExitCode> { - if out.extension().and_then(|e| e.to_str()) != Some("a") { - return Err(fail( - "Android output must end in .a; a matching .h is generated beside it", - )); - } + crate::toolchain::validate_archive_output(out, "Android").map_err(|e| fail(&e))?; let (ir, header) = source(program, path, target).map_err(|e| fail(&e))?; let bin = ndk_bin().map_err(|e| fail(&e))?; let runtime = find_runtime_lib(target.runtime()).ok_or_else(|| { diff --git a/crates/osprey-cli/src/docs.rs b/crates/osprey-cli/src/docs.rs index 0af80b43..66f07800 100644 --- a/crates/osprey-cli/src/docs.rs +++ b/crates/osprey-cli/src/docs.rs @@ -16,7 +16,7 @@ use std::path::{Path, PathBuf}; use std::process::ExitCode; /// Entry point for the `--docs` mode. Reads `--docs-dir ` from `args`. -pub fn run(args: &[String]) -> ExitCode { +pub(crate) fn run(args: &[String]) -> ExitCode { let dir = if let Some(dir) = docs_dir(args) { PathBuf::from(dir) } else { diff --git a/crates/osprey-cli/src/fmt.rs b/crates/osprey-cli/src/fmt.rs index b4aae630..eeb52568 100644 --- a/crates/osprey-cli/src/fmt.rs +++ b/crates/osprey-cli/src/fmt.rs @@ -35,7 +35,7 @@ struct Tally { } /// Entry point for `osprey fmt`; `args` excludes the `fmt` subcommand word. -pub fn run(args: &[String]) -> ExitCode { +pub(crate) fn run(args: &[String]) -> ExitCode { let parsed = match parse(args) { Ok(parsed) => parsed, Err(message) => { diff --git a/crates/osprey-cli/src/ios.rs b/crates/osprey-cli/src/ios.rs index 415fef4f..be3c2370 100644 --- a/crates/osprey-cli/src/ios.rs +++ b/crates/osprey-cli/src/ios.rs @@ -60,18 +60,7 @@ impl Target { /// Refuse native-only settings before invoking the cross compiler. /// Implements [IOS-TARGET-OPTIONS]. pub(crate) fn validate(cli: &Cli) -> Result<(), ExitCode> { - if let Some(code) = crate::reject_debug_cross_target(cli) { - return Err(code); - } - if cli.memory != "default" { - return Err(fail( - "iOS supports --memory=default; other runtime archives are not available", - )); - } - if cli.mode == "--run" { - return Err(fail("iOS produces an app-logic library; use --compile and call it from a Swift host (see examples/ios/)")); - } - Ok(()) + crate::reject_cross_target_options(cli, "iOS", Some("a Swift host (see examples/ios/)")) } /// Emit the app's C ABI and LLVM implementation before any toolchain work. @@ -116,10 +105,7 @@ pub(crate) fn build( } fn validate_output(out: &Path) -> Result<(), String> { - if out.extension().and_then(|e| e.to_str()) != Some("a") { - return Err("iOS output must end in .a; a matching .h is generated beside it".to_string()); - } - Ok(()) + crate::toolchain::validate_archive_output(out, "iOS") } fn sdk_path(target: Target) -> Result { diff --git a/crates/osprey-cli/src/ios_abi_tests.rs b/crates/osprey-cli/src/ios_abi_tests.rs index c314fdf2..e1e8cb05 100644 --- a/crates/osprey-cli/src/ios_abi_tests.rs +++ b/crates/osprey-cli/src/ios_abi_tests.rs @@ -1,4 +1,5 @@ use super::*; +use crate::testkit::shows; use std::path::{Path, PathBuf}; const SOURCE: &str = "extern fn host_log(message: string) -> int\n\ @@ -67,13 +68,23 @@ fn thunks_rename_the_entry_and_forward_with_the_c_bool_convention() { let out = with_host_abi(&ir, &abi).expect("thunked"); assert!(out.contains("define i32 @osprey_main() "), "entry renamed"); assert!(!out.contains("@main("), "no `main` symbol survives"); - assert!(out.contains("define zeroext i1 @osprey_flag(i1 zeroext %p0) {")); - assert!(out.contains(" %r = call i1 @flag(i1 %p0)\n ret i1 %r")); + shows( + &out, + &[ + "define zeroext i1 @osprey_flag(i1 zeroext %p0) {", + " %r = call i1 @flag(i1 %p0)\n ret i1 %r", + ], + ); assert!(out .contains("define void @osprey_shout(i8* %p0) {\n call i64 @shout(i8* %p0)\n ret void")); - assert!(out.contains("define i8* @osprey_greet(i8* %p0) {")); - assert!(out.contains("define double @osprey_scaled(i64 %p0) {")); - assert!(out.contains("define i64 @osprey_total(i64 %p0, i64 %p1) {")); + shows( + &out, + &[ + "define i8* @osprey_greet(i8* %p0) {", + "define double @osprey_scaled(i64 %p0) {", + "define i64 @osprey_total(i64 %p0, i64 %p1) {", + ], + ); assert!(with_host_abi("; no entry here", &abi).is_err()); } @@ -277,8 +288,10 @@ fn unsupported_extern_signatures_report_the_c_boundary_restriction() { fn renaming_imports_preserves_strings_and_similarly_prefixed_symbols() { let (abi, ir) = abi_of("extern fn host_flag(b: bool) -> bool\nfn host_flag_more(b) = host_flag(b)\nfn text() = \"@host_flag( @main(\"\n"); let out = with_host_abi(&ir, &abi).expect("adapted"); - assert!(out.contains("c\"@host_flag( @main(\\00\""), "{out}"); - assert!(out.contains("define i1 @host_flag_more("), "{out}"); + shows( + &out, + &["c\"@host_flag( @main(\\00\"", "define i1 @host_flag_more("], + ); } #[test] diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index cceb1ec1..2ca136a5 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -29,6 +29,9 @@ mod target_capabilities; mod test_cmd; mod test_coverage; mod test_skips; +#[cfg(test)] +#[path = "../../testkit.rs"] +mod testkit; mod toolchain; mod warnings; mod wasm; @@ -382,7 +385,7 @@ pub(crate) fn load_input(cli: &Cli) -> Result { eprintln!("error: --flavor applies to single files; projects select flavor per source"); return Err(ExitCode::from(2)); } - return project::CompilationInput::load_project(path).map_err(|errors| { + return CompilationInput::load_project(path).map_err(|errors| { print_project_errors(&errors, path); ExitCode::FAILURE }); @@ -500,34 +503,37 @@ fn target_error(cli: &Cli, input: &CompilationInput) -> Option { return Some(ExitCode::FAILURE); } if cli.target == "wasm32" { - if let Some(code) = reject_debug_cross_target(cli) { + if let Err(code) = reject_cross_target_options(cli, "wasm32", None) { return Some(code); } - if cli.memory != "default" { - return Some(toolchain::fail( - "wasm32 supports --memory=default; other runtime archives are not available", - )); - } } if let Some(target) = android::Target::parse(&cli.target) { - if let Err(code) = android::validate(cli) { - return Some(code); - } - if cli.mode == "--check" { - return android::source(input.program(), input.debug_path(), target) - .err() - .map(|error| toolchain::fail(&error)); - } + return app_target_error(&cli.mode, android::validate(cli), || { + android::source(input.program(), input.debug_path(), target) + }); } if let Some(target) = ios::Target::parse(&cli.target) { - if let Err(code) = ios::validate(cli) { - return Some(code); - } - if cli.mode == "--check" { - return ios::source(input.program(), input.debug_path(), target) - .err() - .map(|error| toolchain::fail(&error)); - } + return app_target_error(&cli.mode, ios::validate(cli), || { + ios::source(input.program(), input.debug_path(), target) + }); + } + None +} + +/// The app-library targets (iOS, Android) share one order: reject the +/// unsupported options, then — for `--check` alone — generate the C ABI and +/// report its failure as a diagnostic. `source` stays lazy so no other mode +/// pays for ABI generation, and so option errors always win the race. +fn app_target_error( + mode: &str, + validation: Result<(), ExitCode>, + source: impl FnOnce() -> Result<(String, String), String>, +) -> Option { + if let Err(code) = validation { + return Some(code); + } + if mode == "--check" { + return source().err().map(|error| toolchain::fail(&error)); } None } @@ -557,17 +563,43 @@ fn reject_debug_cross_target(cli: &Cli) -> Option { None } +/// Every cross target refuses the native-only build flags and the non-default +/// runtime archives. A target that produces a LIBRARY rather than a runnable +/// image also refuses `--run`, and names the host that calls it in `host_hint`; +/// `None` marks a target with a `--run` form of its own. +/// Implements [IOS-TARGET-OPTIONS] and [ANDROID-TARGET-OPTIONS]. +fn reject_cross_target_options( + cli: &Cli, + platform: &str, + host_hint: Option<&str>, +) -> Result<(), ExitCode> { + if let Some(code) = reject_debug_cross_target(cli) { + return Err(code); + } + if cli.memory != "default" { + return Err(toolchain::fail(&format!( + "{platform} supports --memory=default; other runtime archives are not available" + ))); + } + match host_hint { + Some(hint) if cli.mode == "--run" => Err(toolchain::fail(&format!( + "{platform} produces an app-logic library; use --compile and call it from {hint}" + ))), + _ => Ok(()), + } +} + /// The native build kind this invocation asked for (`--debug` and `--profile` /// are mutually exclusive; `parse_args` enforces that). fn build_kind(cli: &Cli) -> osprey_debug::BuildKind { if cli.debug { - osprey_debug::BuildKind::Debug + osprey_debug::DebugBuild::ON.kind() } else if cli.profile { osprey_debug::BuildKind::Profile } else if std::env::var_os(TEST_COVERAGE_BUILD_ENV).is_some() { osprey_debug::BuildKind::Coverage } else { - osprey_debug::BuildKind::Release + osprey_debug::DebugBuild::OFF.kind() } } diff --git a/crates/osprey-cli/src/toolchain.rs b/crates/osprey-cli/src/toolchain.rs index 6730cee1..cfbb82c5 100644 --- a/crates/osprey-cli/src/toolchain.rs +++ b/crates/osprey-cli/src/toolchain.rs @@ -26,6 +26,17 @@ pub(crate) fn fail(msg: &str) -> ExitCode { ExitCode::FAILURE } +/// An app-library target publishes a static archive plus a matching C header, +/// so `-o` must name the archive. `platform` opens the diagnostic. +pub(crate) fn validate_archive_output(out: &Path, platform: &str) -> Result<(), String> { + if out.extension().and_then(|e| e.to_str()) != Some("a") { + return Err(format!( + "{platform} output must end in .a; a matching .h is generated beside it" + )); + } + Ok(()) +} + pub(crate) fn write(path: &Path, contents: &str) -> Result<(), ExitCode> { std::fs::write(path, contents) .map_err(|e| fail(&format!("cannot write {}: {e}", path.display()))) diff --git a/crates/osprey-cli/src/wasm.rs b/crates/osprey-cli/src/wasm.rs index d21fc9ad..0eacedbf 100644 --- a/crates/osprey-cli/src/wasm.rs +++ b/crates/osprey-cli/src/wasm.rs @@ -284,6 +284,7 @@ fn run_host(wasm: &Path) -> ExitCode { #[cfg(test)] mod tests { use super::*; + use crate::testkit::shows; /// Serializes tests that read/write process-global toolchain env vars /// (`OSPREY_WASM_*`, `*_SYSROOT`) so they neither race each other nor the @@ -336,9 +337,14 @@ mod tests { fn entry_thunk_wraps_main_for_the_wasi_start_path() { // [WASM-ENTRY] let out = with_entry_thunk("define i32 @main() {\n ret i32 0\n}\n"); - assert!(out.contains("define i32 @main()"), "original main kept"); - assert!(out.contains("define i32 @__main_void()"), "thunk added"); - assert!(out.contains("call i32 @main()"), "thunk calls main"); + shows( + &out, + &[ + "define i32 @main()", + "define i32 @__main_void()", + "call i32 @main()", + ], + ); } #[test] @@ -346,9 +352,14 @@ mod tests { // [WASM-WEB-ABI] let mangled = format!("__osp_3x617070{WEB_DISPATCH_MANGLED_SUFFIX}"); let out = with_web_dispatch_thunk("; module", Some(&mangled)); - assert!(out.contains("define i64 @osprey_web_dispatch(i8* %message)")); - assert!(out.contains(&format!("call i64 @{mangled}(i8* %message)"))); - assert!(out.contains("ret i64 %r")); + shows( + &out, + &[ + "define i64 @osprey_web_dispatch(i8* %message)", + &format!("call i64 @{mangled}(i8* %message)"), + "ret i64 %r", + ], + ); let unchanged = with_web_dispatch_thunk("; module", Some(WEB_DISPATCH)); assert_eq!(unchanged, "; module", "source spelling needs no thunk"); diff --git a/crates/osprey-cli/tests/cli_e2e.rs b/crates/osprey-cli/tests/cli_e2e.rs index 2b1e3d01..151c760a 100644 --- a/crates/osprey-cli/tests/cli_e2e.rs +++ b/crates/osprey-cli/tests/cli_e2e.rs @@ -134,16 +134,27 @@ fn run_file_cc(path: &Path, mode: &str, cc: &str) -> Out { finish(cmd) } -/// Type-clean but codegen-rejected: a still-generic lambda used as a bare -/// VALUE has no ABI to fix and no call site to specialise against -/// ([TYPE-GENERICS-FN]). It passes the type gate, so every compiling mode -/// reaches codegen and fails there — exercising the `Err` arms -/// `compile_program` feeds. +/// Type-clean but codegen-rejected: an FFI callback slot is a raw C code +/// pointer, so a capturing lambda has nowhere to carry its environment +/// ([FFI-CALLBACKS]). It passes the type gate, so every compiling mode reaches +/// codegen and fails there — exercising the `Err` arms `compile_program` feeds. /// -/// This used to bind the value first (`let f = mk(1)` then `f(0)`). That shape -/// now COMPILES: the returned lambda is inlined at each call site of the -/// binding, so it no longer reaches a codegen error and could not exercise -/// these arms. +/// `(x + base) ?: 0` discharges the arithmetic `Result`; without it the lambda +/// is `(int) -> Result` and the type gate rejects the call +/// before codegen sees the capture. +const CODEGEN_REJECTED: &str = concat!( + "extern fn registerCallback(cb: fn(int) -> int) -> int\n", + "let base = 10\n", + "let r = registerCallback(fn(x) => (x + base) ?: 0)\n", + "print(\"${r}\")\n", +); + +/// A still-generic lambda used as a bare VALUE: no ABI to fix and no call site +/// to specialise against ([TYPE-GENERICS-FN]). +/// +/// This drove the two codegen-error tests until the checker learned to reject +/// it, which is a strictly better place to catch it. It stays here to pin +/// WHERE it is rejected, so the move cannot happen again unnoticed. const GENERIC_AS_VALUE: &str = "fn mk(x: T) = |y| => x\nprint(\"${mk(1)}\")\n"; /// Explicit effect resume must run the rest of the handled computation and then @@ -727,7 +738,7 @@ fn quiet_suppresses_the_ok_line() { #[test] fn llvm_reports_a_codegen_error() { - let prog = temp_osp("cgllvm", GENERIC_AS_VALUE); + let prog = temp_osp("cgllvm", CODEGEN_REJECTED); let o = run_file(&prog, &["--llvm"]); assert_ne!(o.code, Some(0)); assert!(o.stderr.contains("codegen"), "{}", o.stderr); @@ -735,12 +746,30 @@ fn llvm_reports_a_codegen_error() { #[test] fn run_reports_a_codegen_error() { - let prog = temp_osp("cgrun", GENERIC_AS_VALUE); + let prog = temp_osp("cgrun", CODEGEN_REJECTED); let o = run_file(&prog, &["--run"]); assert_ne!(o.code, Some(0)); assert!(o.stderr.contains("codegen"), "{}", o.stderr); } +#[test] +fn a_generic_closure_value_is_rejected_by_the_type_gate() { + // The two tests above assert a CODEGEN failure, so they go quiet the moment + // their input starts being rejected earlier — which is exactly what happened + // to this program. Pinning the checker's message here means a future move of + // the gate fails a test that names the gate, instead of silently draining + // the codegen arms of coverage. + let prog = temp_osp("genval", GENERIC_AS_VALUE); + let o = run_file(&prog, &["--llvm"]); + assert_ne!(o.code, Some(0)); + assert!( + o.stderr + .contains("a closure value with a still-generic type cannot be interpolated"), + "{}", + o.stderr + ); +} + #[test] fn compile_reports_a_failing_c_compiler() { // `false` runs and exits non-zero -> the "cc failed to compile" branch. diff --git a/crates/osprey-cli/tests/common/mod.rs b/crates/osprey-cli/tests/common/mod.rs index 02280424..67ae8c5d 100644 --- a/crates/osprey-cli/tests/common/mod.rs +++ b/crates/osprey-cli/tests/common/mod.rs @@ -12,13 +12,13 @@ use std::path::{Path, PathBuf}; /// /// Left un-canonicalized on purpose: there is no fallible call to unwrap, and /// the `..` components resolve the same way for every consumer here. -pub fn repo_root() -> PathBuf { +pub(crate) fn repo_root() -> PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")).join("..").join("..") } /// Every file with extension `ext` under `dir`, recursively, sorted so a /// failure names the same program on every machine. -pub fn sources(dir: &Path, ext: &str) -> Vec { +pub(crate) fn sources(dir: &Path, ext: &str) -> Vec { let mut out = Vec::new(); collect(dir, ext, &mut out); out.sort(); @@ -47,7 +47,7 @@ fn collect(dir: &Path, ext: &str, out: &mut Vec) { /// an instantiation that was never emitted collapsed onto one that was and the /// gate reported a clean module — the exact dangling reference it exists to /// catch ([`crate::monofn::specialize_callback`]). -pub fn symbol_at(rest: &str) -> Option { +pub(crate) fn symbol_at(rest: &str) -> Option { let name: String = rest .chars() .take_while(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '.' || *c == '$') @@ -57,7 +57,7 @@ pub fn symbol_at(rest: &str) -> Option { } /// Every `@symbol` the module BINDS — defined, declared or a global. -pub fn bound_symbols(ir: &str) -> BTreeSet { +pub(crate) fn bound_symbols(ir: &str) -> BTreeSet { let mut bound = BTreeSet::new(); for line in ir.lines() { let trimmed = line.trim_start(); @@ -83,7 +83,7 @@ pub fn bound_symbols(ir: &str) -> BTreeSet { /// global initializer is a use like any other (`@table = global i8* @missing`), /// and skipping the whole line let exactly that reference through: the one form /// where a dangling symbol is written on the same line as a definition. -pub fn undefined_symbols(ir: &str) -> BTreeSet { +pub(crate) fn undefined_symbols(ir: &str) -> BTreeSet { let bound = bound_symbols(ir); let mut missing = BTreeSet::new(); for line in ir.lines() { diff --git a/crates/osprey-cli/tests/common/staging.rs b/crates/osprey-cli/tests/common/staging.rs index dc134847..f425a1e8 100644 --- a/crates/osprey-cli/tests/common/staging.rs +++ b/crates/osprey-cli/tests/common/staging.rs @@ -9,7 +9,7 @@ use osprey_syntax::{parse_program_with_flavor, Flavor}; /// Parse — which discharges static handlers at the flavor boundary /// ([STAGE-LOWER-ORDER-PHASE]) — and emit LLVM IR. -pub fn compile_staged(source: &str) -> String { +pub(crate) fn compile_staged(source: &str) -> String { let parsed = parse_program_with_flavor(source, Flavor::Default); assert!( parsed.errors.is_empty(), @@ -22,7 +22,7 @@ pub fn compile_staged(source: &str) -> String { } /// Every diagnostic the frontend produces for `source`, joined for matching. -pub fn diagnostics(source: &str, flavor: Flavor) -> String { +pub(crate) fn diagnostics(source: &str, flavor: Flavor) -> String { let parsed = parse_program_with_flavor(source, flavor); if !parsed.errors.is_empty() { return parsed @@ -42,7 +42,7 @@ pub fn diagnostics(source: &str, flavor: Flavor) -> String { /// Compile `source` for `target` through the real CLI, returning stderr and /// whether it succeeded — the only path that runs the per-target capability /// gate [MULTI-WASM] and [STAGE-WASM] are checked by. -pub fn compile_for_target(source: &str, target: &str) -> (bool, String) { +pub(crate) fn compile_for_target(source: &str, target: &str) -> (bool, String) { let dir = std::env::temp_dir().join(format!( "osprey_staged_{}_{:?}", std::process::id(), diff --git a/crates/osprey-cli/tests/staged_effects.rs b/crates/osprey-cli/tests/staged_effects.rs index b3736d91..615eab91 100644 --- a/crates/osprey-cli/tests/staged_effects.rs +++ b/crates/osprey-cli/tests/staged_effects.rs @@ -11,7 +11,7 @@ #[path = "common/staging.rs"] mod staging; -use osprey_syntax::{dependency_sets, Flavor}; +use osprey_syntax::{dependency_report, Flavor}; use staging::{compile_for_target, compile_staged, diagnostics}; /// The C runtime symbols a dynamic handler region registers and looks up. @@ -75,7 +75,7 @@ fn greeting() = "hello ${perform NameSignal.read()}" fn statusBar() = "${greeting()} | ${counterLabel()}" fn footer() = "osprey" "#; - let deps = dependency_sets(source, Flavor::Default); + let deps = dependency_report(source, Flavor::Default).0; let of = |name: &str| deps.get(name).cloned().unwrap_or_default(); assert_eq!(of("doubled"), vec!["CountSignal.read"]); // Transitive through a call, and only what is actually read. @@ -101,7 +101,7 @@ fn root() = handle static CountSignal read => 7 in label() "#; - let deps = dependency_sets(source, Flavor::Default); + let deps = dependency_report(source, Flavor::Default).0; assert_eq!( deps.get("label").cloned().unwrap_or_default(), vec!["CountSignal.read"] @@ -258,7 +258,7 @@ static effect Signal { read: fn() -> T } fn counterLabel() = "count: ${(perform Signal.read()).value}" fn cursorLabel() = "at: ${(perform Signal.read()).at}" "#; - let deps = dependency_sets(source, Flavor::Default); + let deps = dependency_report(source, Flavor::Default).0; let of = |name: &str| deps.get(name).cloned().unwrap_or_default(); assert_eq!( of("counterLabel"), diff --git a/crates/osprey-codegen/src/aggregate.rs b/crates/osprey-codegen/src/aggregate.rs index d5defe76..60a18191 100644 --- a/crates/osprey-codegen/src/aggregate.rs +++ b/crates/osprey-codegen/src/aggregate.rs @@ -200,8 +200,7 @@ fn own_struct_handle( obj: &str, owner: impl Into, ) -> Value { - let handle = cg.fresh_reg(); - cg.emit(format!("{handle} = bitcast {struct_ty}* {obj} to i8*")); + let handle = cg.emit_reg(format!("bitcast {struct_ty}* {obj} to i8*")); let v = Value::handle(handle, owner); crate::arc::own(cg, &v); v @@ -249,9 +248,8 @@ fn gen_http_response(cg: &mut Codegen, fields: &[FieldAssignment]) -> Result crate::cast::coerce_to(cg, v, LType::Str)?.operand, }; crate::arc::dup_store(cg, llty, &operand); - let p = cg.fresh_reg(); - cg.emit(format!( - "{p} = getelementptr {HTTP_RESPONSE_STRUCT}, {HTTP_RESPONSE_STRUCT}* {obj}, i32 0, i32 {i}" + let p = cg.emit_reg(format!( + "getelementptr {HTTP_RESPONSE_STRUCT}, {HTTP_RESPONSE_STRUCT}* {obj}, i32 0, i32 {i}" )); cg.emit(format!("store {llty} {operand}, {llty}* {p}")); } @@ -316,11 +314,7 @@ pub(crate) fn gen_update( .ctor_struct_ty(&owner) .ok_or_else(|| CodegenError::unknown(&owner))?; - let src = cg.fresh_reg(); - cg.emit(format!( - "{src} = bitcast i8* {} to {struct_ty}*", - base.operand - )); + let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", base.operand)); // view.meta comes from the Osprey field types (builder.rs `field_meta`), // which prove more than the erased LTypes visible here: an all-union field // set upgrades to the probe-free KIND_MASK_DIRECT. noinit: the tag and every @@ -362,6 +356,14 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> let owner = known .or_else(|| cg.find_field_owner(field)) .ok_or_else(|| CodegenError::invalid(format!("field `{field}` on a non-record")))?; + // Ordinary records can cross an inlined generic call with only their owner + // tag. Keep a concrete field's complete type, including every returned + // function arrow, so chained calls retain their ABI. [TYPE-FN-HIGHER-ORDER] + let inferred = inferred.or_else(|| { + cg.prog + .field_type(&osprey_types::Type::con(&owner, Vec::new()), field) + .filter(|ty| !osprey_types::has_type_var(ty)) + }); if cg.ctor_field_result_inner(&owner, field).is_some() { return Err(result_field_unsupported()); } @@ -379,11 +381,7 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> // parameter whose type is still a variable — travels in the uniform machine // word, so restore the handle before reading a slot out of it. let tv = crate::cast::coerce_to(cg, tv, LType::Ptr)?; - let src = cg.fresh_reg(); - cg.emit(format!( - "{src} = bitcast i8* {} to {struct_ty}*", - tv.operand - )); + let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", tv.operand)); let loaded = load_field(cg, &struct_ty, src.as_str(), idx + 1, fty); // A handle field carries its ELEMENT's ABI, not an owner of its own: the // slot holds a runtime id, and `recv`/`await` on it needs the element type @@ -434,9 +432,8 @@ pub(crate) fn store_field( if !moved { crate::arc::dup_store(cg, fty.as_str(), val); } - let p = cg.fresh_reg(); - cg.emit(format!( - "{p} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}" + let p = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}" )); cg.emit(format!("store {fty} {val}, {fty}* {p}")); } @@ -456,11 +453,9 @@ pub(crate) fn load_field( idx: usize, fty: LType, ) -> String { - let p = cg.fresh_reg(); - cg.emit(format!( - "{p} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}" + let p = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}" )); - let r = cg.fresh_reg(); - cg.emit(format!("{r} = load {fty}, {fty}* {p}")); + let r = cg.emit_reg(format!("load {fty}, {fty}* {p}")); r } diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs index 4521483b..656b1743 100644 --- a/crates/osprey-codegen/src/builder.rs +++ b/crates/osprey-codegen/src/builder.rs @@ -14,7 +14,7 @@ use std::fmt::Write as _; /// Code generation switches that alter the emitted module without changing /// Osprey semantics. #[derive(Debug, Clone, Default)] -pub struct CodegenOptions { +pub(crate) struct CodegenOptions { /// Source file identity used for LLVM/DWARF debug metadata. pub debug_source: Option, /// Instrument coverable lines with hit counters [TESTING-COVERAGE-CODEGEN]. @@ -26,11 +26,7 @@ pub struct CodegenOptions { /// A lambda kept for inline application at its direct call sites: its /// parameters, its body, and the position inference keyed its type by. -pub(crate) type LambdaDef = ( - Vec, - osprey_ast::Expr, - Option, -); +pub(crate) type LambdaDef = (Vec, Expr, Option); /// What the program turned out to CONTAIN — decided while lowering, read once /// by `main`'s epilogue. These belong together because they are answered the @@ -52,7 +48,7 @@ pub(crate) struct Lowered { } /// Accumulates a whole module while lowering one function at a time. -pub struct Codegen { +pub(crate) struct Codegen { /// `declare` lines, de-duplicated and stably ordered. externs: BTreeSet, /// Global constant definitions (string literals). @@ -74,6 +70,9 @@ pub struct Codegen { /// Declared parameter names per function, for named-argument ordering. pub(crate) fn_params: HashMap>, + /// Extern parameter names. Kept separate because `fn_params` also identifies + /// Osprey functions whose callbacks use closure cells rather than C pointers. + pub(crate) extern_params: HashMap>, /// Type names an `extern fn` claims to return (every name in the declared /// return type expression, conservatively). A foreign pointer typed as a /// union would break the `KIND_MASK_DIRECT` all-children-are-ARC-bodies @@ -145,7 +144,7 @@ pub struct Codegen { /// function at each call site so its type variables monomorphize to the /// concrete argument types there (specialisation by inlining rather than by /// emitting a name-mangled copy per instantiation). - pub(crate) fn_defs: HashMap, osprey_ast::Expr)>, + pub(crate) fn_defs: HashMap, Expr)>, /// Generic functions currently being inlined — a re-entry guard so a /// (mutually) recursive generic call falls back to a direct call instead of /// inlining forever. @@ -608,18 +607,18 @@ impl DebugState { } impl Codegen { - pub fn new() -> Codegen { + pub(crate) fn new() -> Codegen { Codegen::with_types(ProgramTypes::default()) } /// Build with the inferred program types that drive parameter/return/value /// typing. - pub fn with_types(prog: ProgramTypes) -> Codegen { + pub(crate) fn with_types(prog: ProgramTypes) -> Codegen { Codegen::with_options(prog, CodegenOptions::default()) } /// Build with inferred program types and explicit code generation options. - pub fn with_options(prog: ProgramTypes, options: CodegenOptions) -> Codegen { + pub(crate) fn with_options(prog: ProgramTypes, options: CodegenOptions) -> Codegen { Codegen { externs: BTreeSet::new(), globals: Vec::new(), @@ -634,6 +633,7 @@ impl Codegen { scope_ids: Vec::new(), next_scope_id: 0, fn_params: HashMap::new(), + extern_params: HashMap::new(), extern_ret_types: BTreeSet::new(), nullary_singletons: HashMap::new(), prog, @@ -755,13 +755,7 @@ impl Codegen { /// unique field-name match across known layouts. fn field_fn_type(&self, target: &Expr, field: &str) -> Option { let owner = self.callee_field_owner(target, field)?; - self.prog - .ctors - .get(&owner)? - .fields - .iter() - .find(|(f, _)| f == field) - .map(|(_, t)| t.clone()) + self.ctor_field_ty(&owner, field).cloned() } /// Resolve the owner type of `target.field`: prefer a bound identifier's @@ -778,12 +772,21 @@ impl Codegen { self.find_field_owner(field) } - /// Whether `owner`'s layout declares `field`. - fn declares_field(&self, owner: &str, field: &str) -> bool { + /// The declared type of `field` on constructor `owner` — the single field + /// lookup behind [`Self::declares_field`] and every `ctor_field_*` accessor. + fn ctor_field_ty(&self, owner: &str, field: &str) -> Option<&Type> { self.prog .ctors - .get(owner) - .is_some_and(|c| c.fields.iter().any(|(f, _)| f == field)) + .get(owner)? + .fields + .iter() + .find(|(f, _)| f == field) + .map(|(_, t)| t) + } + + /// Whether `owner`'s layout declares `field`. + fn declares_field(&self, owner: &str, field: &str) -> bool { + self.ctor_field_ty(owner, field).is_some() } /// Whether `name` is a user function whose inferred signature still contains @@ -987,7 +990,7 @@ impl Codegen { pub(crate) fn fn_ret_is_unit(&self, name: &str) -> bool { self.prog .return_type(name) - .is_some_and(|t| *t == osprey_types::Type::unit()) + .is_some_and(|t| *t == Type::unit()) } /// The LLVM parameter types of a user function, from inference. @@ -1084,7 +1087,7 @@ impl Codegen { /// smuggle in a foreign pointer and break the proof. Everything else /// (strings can be rodata, records can cross the C ABI, `Ptr` is FFI) /// keeps the probe-tolerant `LType` mapping. [GC-ARC-PERCEUS] - fn field_meta(&self, t: &osprey_types::Type) -> crate::meta::MetaField { + fn field_meta(&self, t: &Type) -> crate::meta::MetaField { let proven = crate::types::proven_heap_name(t).is_some_and(|n| { self.prog.unions.contains_key(n) && !self.extern_ret_types.contains(n) }); @@ -1172,14 +1175,7 @@ impl Codegen { .find(|(f, _, _)| f == field) .and_then(|(_, _, tag)| tag.clone()); } - let ty = self - .prog - .ctors - .get(owner)? - .fields - .iter() - .find(|(f, _)| f == field) - .map(|(_, t)| t.clone())?; + let ty = self.ctor_field_ty(owner, field)?.clone(); let head = crate::types::owner_name(&self.prog, &ty)?; let known = self.prog.ctors.contains_key(&head) || self.prog.unions.contains_key(&head) @@ -1198,30 +1194,16 @@ impl Codegen { /// read the wire word raw and the element came back untyped. /// Implements [CONCURRENCY-CHANNEL]. pub(crate) fn ctor_field_handle(&self, owner: &str, field: &str) -> Option { - let ty = self - .prog - .ctors - .get(owner)? - .fields - .iter() - .find(|(name, _)| name == field) - .map(|(_, ty)| ty)?; - FiberSig::of(&self.prog, ty) + FiberSig::of(&self.prog, self.ctor_field_ty(owner, field)?) } pub(crate) fn ctor_field_result_inner(&self, owner: &str, field: &str) -> Option { - self.prog - .ctors - .get(owner)? - .fields - .iter() - .find(|(name, _)| name == field) - .and_then(|(_, ty)| crate::types::result_inner(ty)) + crate::types::result_inner(self.ctor_field_ty(owner, field)?) } /// The variant constructor names of a union owner, in tag order. pub(crate) fn union_variants(&self, owner: &str) -> Option<&[String]> { - self.prog.unions.get(owner).map(std::vec::Vec::as_slice) + self.prog.unions.get(owner).map(Vec::as_slice) } // ---- SSA + block naming (function-local) ---- @@ -1254,6 +1236,17 @@ impl Codegen { /// Emit `r = {rhs}` to a fresh SSA register and return `r` — the ubiquitous /// "name the result of one instruction" step (`zext …`, `icmp …`, `fneg …`). + /// Open a diamond on `cond`: mint the two arm labels plus the join they + /// both reach, and emit the branch between them. Answers + /// `(true_arm, false_arm, join)`; the caller starts whichever arm it means + /// to fill first. Minting labels apart from the `br` that names them is how + /// a block ends up unterminated, so the two steps are one call. + pub(crate) fn diamond(&mut self, cond: &str) -> (String, String, String) { + let (taken, other, join) = (self.fresh_label(), self.fresh_label(), self.fresh_label()); + self.emit(format!("br i1 {cond}, label %{taken}, label %{other}")); + (taken, other, join) + } + pub(crate) fn emit_reg(&mut self, rhs: impl std::fmt::Display) -> String { let r = self.fresh_reg(); self.emit(format!("{r} = {rhs}")); @@ -1305,8 +1298,7 @@ impl Codegen { }; self.add_extern("declare void @llvm.dbg.declare(metadata, metadata, metadata)"); let ty = value.ty.as_str(); - let slot = self.fresh_reg(); - self.emit(format!("{slot} = alloca {ty}")); + let slot = self.emit_reg(format!("alloca {ty}")); self.emit(format!("store {ty} {}, {ty}* {slot}", value.operand)); self.emit(format!( "call void @llvm.dbg.declare(metadata {ty}* {slot}, metadata !{var_id}, metadata !DIExpression())" @@ -1377,9 +1369,8 @@ impl Codegen { self.globals.push(format!( "{name} = private unnamed_addr constant [{len} x i8] c\"{escaped}\"" )); - let reg = self.fresh_reg(); - self.emit(format!( - "{reg} = getelementptr [{len} x i8], [{len} x i8]* {name}, i64 0, i64 0" + let reg = self.emit_reg(format!( + "getelementptr [{len} x i8], [{len} x i8]* {name}, i64 0, i64 0" )); let _ = self.rodata_regs.insert(reg.clone()); Value::new(reg, LType::Str) @@ -1618,19 +1609,16 @@ impl Codegen { } fn malloc_struct_with(&mut self, struct_ty: &str, meta: i64, noinit: bool) -> String { - let szp = self.fresh_reg(); - self.emit(format!( - "{szp} = getelementptr {struct_ty}, {struct_ty}* null, i64 1" + let szp = self.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* null, i64 1" )); - let sz = self.fresh_reg(); - self.emit(format!("{sz} = ptrtoint {struct_ty}* {szp} to i64")); + let sz = self.emit_reg(format!("ptrtoint {struct_ty}* {szp} to i64")); let raw = if noinit { self.heap_alloc_tagged_noinit(&sz, meta) } else { self.heap_alloc_tagged(&sz, meta) }; - let obj = self.fresh_reg(); - self.emit(format!("{obj} = bitcast i8* {raw} to {struct_ty}*")); + let obj = self.emit_reg(format!("bitcast i8* {raw} to {struct_ty}*")); obj } diff --git a/crates/osprey-codegen/src/call.rs b/crates/osprey-codegen/src/call.rs index 7a4cec0e..457858ab 100644 --- a/crates/osprey-codegen/src/call.rs +++ b/crates/osprey-codegen/src/call.rs @@ -31,8 +31,7 @@ impl Codegen { /// result register `r`. pub(crate) fn call(&mut self, ret: &str, cname: &str, params: &str, args: &[&str]) -> String { let typed = declare_and_args(self, ret, cname, params, args); - let r = self.fresh_reg(); - self.emit(format!("{r} = call {ret} @{cname}({typed})")); + let r = self.emit_reg(format!("call {ret} @{cname}({typed})")); r } diff --git a/crates/osprey-codegen/src/cast.rs b/crates/osprey-codegen/src/cast.rs index 6c1af255..8fb9dcde 100644 --- a/crates/osprey-codegen/src/cast.rs +++ b/crates/osprey-codegen/src/cast.rs @@ -49,8 +49,7 @@ pub(crate) fn coerce_to(cg: &mut Codegen, v: Value, want: LType) -> Result Result { let is_str = needle.ty == LType::Str; let boxed = box_to_i64(cg, needle.clone()); - let res = cg.fresh_reg(); - cg.emit(format!("{res} = alloca i1")); + let res = cg.emit_reg("alloca i1"); cg.emit(format!("store i1 0, i1* {res}")); let lp = open_list_loop(cg, &l.operand); let eq = cg.fresh_reg(); if is_str { - let ep = cg.fresh_reg(); - cg.emit(format!("{ep} = inttoptr i64 {} to i8*", lp.elem)); + let ep = cg.emit_reg(format!("inttoptr i64 {} to i8*", lp.elem)); let c = cg.call("i32", "strcmp", "i8*, i8*", &[&ep, &needle.operand]); cg.emit(format!("{eq} = icmp eq i32 {c}, 0")); } else { @@ -402,8 +399,7 @@ fn list_contains(cg: &mut Codegen, args: &[Expr]) -> Result { cg.start_block(&cont); close_list_loop(cg, &lp); - let out = cg.fresh_reg(); - cg.emit(format!("{out} = load i1, i1* {res}")); + let out = cg.emit_reg(format!("load i1, i1* {res}")); Ok(Value::new(out, LType::I1)) } @@ -453,8 +449,7 @@ fn map_contains(cg: &mut Codegen, args: &[Expr]) -> Result { "i8*, i64", &[&m.operand, &k.operand], ); - let r = cg.fresh_reg(); - cg.emit(format!("{r} = icmp ne i32 {raw}, 0")); + let r = cg.emit_reg(format!("icmp ne i32 {raw}, 0")); Ok(Value::new(r, LType::I1)) } @@ -536,10 +531,8 @@ fn map_to_list(cg: &mut Codegen, args: &[Expr], take_key: bool) -> Result let managed = cg.call("i32", kind, "i8*", &[&m.operand]); let bld = list_builder_new_of(cg, &managed); let iter = cg.call("i8*", "osprey_map_iter_new", "i8*", &[&m.operand]); - let kp = cg.fresh_reg(); - cg.emit(format!("{kp} = alloca i64")); - let vp = cg.fresh_reg(); - cg.emit(format!("{vp} = alloca i64")); + let kp = cg.emit_reg("alloca i64"); + let vp = cg.emit_reg("alloca i64"); let cond = cg.fresh_label(); let body = cg.fresh_label(); @@ -553,14 +546,12 @@ fn map_to_list(cg: &mut Codegen, args: &[Expr], take_key: bool) -> Result "i8*, i64*, i64*", &[&iter, &kp, &vp], ); - let more = cg.fresh_reg(); - cg.emit(format!("{more} = icmp ne i32 {has}, 0")); + let more = cg.emit_reg(format!("icmp ne i32 {has}, 0")); cg.emit(format!("br i1 {more}, label %{body}, label %{endl}")); cg.start_block(&body); let slot = if take_key { &kp } else { &vp }; - let elem = cg.fresh_reg(); - cg.emit(format!("{elem} = load i64, i64* {slot}")); + let elem = cg.emit_reg(format!("load i64, i64* {slot}")); list_builder_push_borrowed(cg, &bld, &elem); cg.emit(format!("br label %{cond}")); diff --git a/crates/osprey-codegen/src/effects.rs b/crates/osprey-codegen/src/effects.rs index 8656355c..800d09e6 100644 --- a/crates/osprey-codegen/src/effects.rs +++ b/crates/osprey-codegen/src/effects.rs @@ -15,7 +15,7 @@ use crate::expr::gen_expr; use crate::llty::{LType, Value}; use crate::types::{ltype_of, result_inner}; use osprey_ast::freevars::free_idents; -use osprey_ast::{contains_resume, Expr, HandlerArm, MatchArm, Stmt}; +use osprey_ast::{contains_resume, AstNode, Expr, HandlerArm, Stmt}; use osprey_types::ProgramTypes; use std::collections::{BTreeSet, HashSet}; @@ -237,8 +237,7 @@ fn emit_unhandled_guard(cg: &mut Codegen, raw: &str, lookup_key: &str, operation "br i1 {is_null}, label %{abort_lbl}, label %{ok_lbl}" )); cg.start_block(&abort_lbl); - let p = cg.fresh_reg(); - cg.emit(format!("{p} = call i32 @puts(i8* {})", msg.operand)); + let _ = cg.emit_reg(format!("call i32 @puts(i8* {})", msg.operand)); cg.emit("call void @exit(i32 1)"); cg.emit("unreachable"); cg.start_block(&ok_lbl); @@ -281,133 +280,21 @@ pub(crate) fn captured_mut_vars_in_stmts(stmts: &[&Stmt]) -> HashSet { muts.intersection(&captured).cloned().collect() } -// A purpose-built AST walk (parallel in *shape* to `freevars::walk`, but -// collecting two different sets: every mutable binding and the names handler -// arms reference freely). The handler-arm free idents themselves come from -// `free_idents` so that one definition of "what does this close over" stays in -// `freevars`; only the find-the-handlers/muts traversal lives here. +// Capture rules stay local; structural child enumeration is shared with the +// other AST passes so new expression variants have one traversal table. fn scan_expr(e: &Expr, muts: &mut BTreeSet, captured: &mut BTreeSet) { - match e { - Expr::Handler { arms, body, .. } => { - for arm in arms { - captured.extend(arm_free_idents(arm)); - scan_expr(&arm.body, muts, captured); - } - scan_expr(body, muts, captured); - } - Expr::Block { statements, value } => { - for s in statements { - scan_stmt(s, muts, captured); - } - if let Some(v) = value { - scan_expr(v, muts, captured); - } + if let Expr::Handler { arms, .. } = e { + for arm in arms { + captured.extend(arm_free_idents(arm)); } - Expr::Match { value, arms } => { - scan_expr(value, muts, captured); - scan_arms(arms, muts, captured); - } - Expr::Select { arms } => scan_arms(arms, muts, captured), - _ => scan_children(e, muts, captured), } -} - -fn scan_arms(arms: &[MatchArm], muts: &mut BTreeSet, captured: &mut BTreeSet) { - scan_slice(arms, muts, captured, |arm| &arm.body); -} - -/// Recurse into every child expression of `e` (the variants that are not -/// special-cased in [`scan_expr`]), so a handler/mut nested anywhere is found. -fn scan_children(e: &Expr, muts: &mut BTreeSet, captured: &mut BTreeSet) { - match e { - Expr::InterpolatedStr(parts) => { - for p in parts { - if let osprey_ast::InterpolatedPart::Expr(x) = p { - scan_expr(x, muts, captured); - } - } - } - Expr::List(xs, _) => scan_slice(xs, muts, captured, |x| x), - Expr::Map(es) => { - for en in es { - scan_expr(&en.key, muts, captured); - scan_expr(&en.value, muts, captured); - } - } - Expr::Object(fs) - | Expr::TypeConstructor { fields: fs, .. } - | Expr::Update { fields: fs, .. } => { - scan_slice(fs, muts, captured, |f| &f.value); - } - Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - scan_expr(left, muts, captured); - scan_expr(right, muts, captured); - } - Expr::Unary { operand, .. } => scan_expr(operand, muts, captured), - Expr::Call { - function, - arguments, - named_arguments, - } => { - scan_expr(function, muts, captured); - scan_args(arguments, named_arguments, muts, captured); - } - Expr::MethodCall { - target, - arguments, - named_arguments, - .. - } => { - scan_expr(target, muts, captured); - scan_args(arguments, named_arguments, muts, captured); - } - Expr::FieldAccess { target, .. } => scan_expr(target, muts, captured), - Expr::Index { target, index } => { - scan_expr(target, muts, captured); - scan_expr(index, muts, captured); - } - Expr::Lambda { body, .. } | Expr::Spawn(body) | Expr::Await(body) | Expr::Recv(body) => { - scan_expr(body, muts, captured); - } - Expr::Yield(Some(x)) => scan_expr(x, muts, captured), - Expr::Send { channel, value } => { - scan_expr(channel, muts, captured); - scan_expr(value, muts, captured); - } - Expr::Perform { - arguments, - named_arguments, - .. - } => scan_args(arguments, named_arguments, muts, captured), - Expr::Resume(Some(value)) => scan_expr(value, muts, captured), - _ => {} + // Preserve this collector's existing exclusion of specialized operands. + if matches!(e, Expr::TypeApply { .. }) { + return; } -} - -/// Scan a callee-style argument list: positional arguments then the named -/// ones, in source order. Shared by every call-shaped node (call, method call, -/// `perform`) so none of them can forget a half. -fn scan_args( - arguments: &[Expr], - named_arguments: &[osprey_ast::NamedArgument], - muts: &mut BTreeSet, - captured: &mut BTreeSet, -) { - scan_slice(arguments, muts, captured, |x| x); - scan_slice(named_arguments, muts, captured, |n| &n.value); -} - -/// Recurse into each element of `items`, projecting it to its sub-expression -/// with `pick`. The one place the effect scanner fans out over a collection -/// node, threading `muts`/`captured` through [`osprey_ast::walk_each`]. -fn scan_slice( - items: &[T], - muts: &mut BTreeSet, - captured: &mut BTreeSet, - pick: impl Fn(&T) -> &Expr, -) { - osprey_ast::walk_each(items, &mut (muts, captured), pick, |e, (m, c)| { - scan_expr(e, m, c); + AstNode::Expression(e).for_each_child(|child| match child { + AstNode::Statement(statement) => scan_stmt(statement, muts, captured), + AstNode::Expression(expression) => scan_expr(expression, muts, captured), }); } @@ -465,14 +352,9 @@ pub(crate) fn gen_handler( emit_handler_fn(cg, &fn_name, arm, &sig, resolved, &caps, &env_ty)?; let eff_s = cg.string_constant(&key); let op_s = cg.string_constant(&arm.operation); - let fp = cg.fresh_reg(); - cg.emit(format!( - "{fp} = bitcast {} @{fn_name} to i8*", - sig.fn_ptr_ty() - )); - let r = cg.fresh_reg(); - cg.emit(format!( - "{r} = call i32 @__osprey_handler_push(i8* {}, i8* {}, i8* {fp}, i8* {env})", + let fp = cg.emit_reg(format!("bitcast {} @{fn_name} to i8*", sig.fn_ptr_ty())); + let _ = cg.emit_reg(format!( + "call i32 @__osprey_handler_push(i8* {}, i8* {}, i8* {fp}, i8* {env})", eff_s.operand, op_s.operand )); } @@ -480,8 +362,7 @@ pub(crate) fn gen_handler( let result = gen_expr(cg, body)?; for _ in arms { - let r = cg.fresh_reg(); - cg.emit(format!("{r} = call i32 @__osprey_handler_pop()")); + let _ = cg.emit_reg("call i32 @__osprey_handler_pop()"); } // The popped region's env reached its structural end: drop it (its mask // releases the captured values) [GC-ARC-PERCEUS]. @@ -708,23 +589,28 @@ fn coerce_to_op_result( result_inner: Option, ) -> Result { match result_inner { - Some(inner) if value.result_inner.is_some() => { - crate::result::repack_to_inner(cg, value, inner) - } - Some(inner) => crate::result::make_ok(cg, value, inner), + Some(inner) => promote_to_result(cg, value, inner), None => coerce_to(cg, value, ret_ty), } } +/// Carry `value` into a `Result` answer slot: repack one that is +/// already a Result, else apply the language's safe `T -> Success(T)` +/// promotion. Never erases a discriminant. +fn promote_to_result(cg: &mut Codegen, value: Value, inner: LType) -> Result { + if value.result_inner.is_some() { + crate::result::repack_to_inner(cg, value, inner) + } else { + crate::result::make_ok(cg, value, inner) + } +} + /// Coerce an arm answer without ever erasing a Result. The only /// representation-changing coercion allowed here is the language's safe /// `T -> Success(T)` promotion when the handled expression itself is Result. fn coerce_to_answer(cg: &mut Codegen, value: Value, answer: &AnswerShape) -> Result { match answer.result_inner { - Some(inner) if value.result_inner.is_some() => { - crate::result::repack_to_inner(cg, value, inner) - } - Some(inner) => crate::result::make_ok(cg, value, inner), + Some(inner) => promote_to_result(cg, value, inner), // An arm that does not `resume` abandons the continuation, so ITS value // becomes the whole `handle` block's result. Whether it CAN be that // result is settled in inference, where the semantic types still exist @@ -918,9 +804,7 @@ fn emit_resuming_arm_fn(cg: &mut Codegen, arm: &HandlerArm, spec: &ArmFnSpec<'_> (LType::Ptr, String::from("__coro")), ]; bind_arm_params(cg, arm, spec.sig, spec.resolved, &mut params); - let op_ret_ty = spec - .resolved - .map_or(spec.sig.ret, |r| crate::types::ltype_of(&r.ret)); + let op_ret_ty = spec.resolved.map_or(spec.sig.ret, |r| ltype_of(&r.ret)); let op_ret_result_inner = spec .resolved .and_then(|r| result_inner(&r.ret)) @@ -1110,12 +994,7 @@ pub(crate) fn gen_resume(cg: &mut Codegen, value: Option<&Expr>) -> Result { @@ -1031,8 +1029,8 @@ fn gen_call( let arg = first_arg(arguments, named) .ok_or_else(|| CodegenError::invalid("toFloat needs one argument"))?; let v = gen_expr(cg, arg)?; - let n = crate::conv::as_i64(cg, v)?; - crate::conv::as_double(cg, n) + let n = as_i64(cg, v)?; + as_double(cg, n) } // Compatibility names for the same checked integer operations used by // the natural operators. @@ -1059,6 +1057,38 @@ fn gen_call( } } +/// Normalize a value call before an inlining alias exposes a declaration's +/// formal parameter names. The implicit UFCS receiver stays before its values. +fn alias_slot_arguments( + cg: &Codegen, + name: &str, + arguments: &[Expr], + named: &[NamedArgument], +) -> Option> { + (!named.is_empty() && cg.call_aliases.contains_key(name)).then(|| { + arguments + .iter() + .chain(named.iter().map(|argument| &argument.value)) + .cloned() + .collect() + }) +} + +fn call_result_sig(cg: &Codegen, function: &Expr) -> Option { + let Expr::Call { + function: inner, .. + } = function + else { + return None; + }; + let Expr::Identifier(name) = &**inner else { + return None; + }; + cg.call_result_fn_type(name) + .as_ref() + .and_then(|ty| Codegen::fn_value_sig(&cg.prog, ty)) +} + /// Call through an evaluated function value: lower the callee expression to a /// closure handle, coerce the arguments to the signature's parameter types, /// and call through the cell. @@ -1115,8 +1145,8 @@ fn apply_bound_lambda( name: &str, params: &[Parameter], body: &Expr, - position: Option, - arguments: &[Expr], + position: Option, + arguments: &[&Expr], ) -> Result { let Some((prefix_params, prefix_values)) = cg.lambda_prefix.get(name).cloned() else { return apply_lambda(cg, params, body, position, arguments); @@ -1135,8 +1165,8 @@ fn apply_lambda( cg: &mut Codegen, parameters: &[Parameter], body: &Expr, - position: Option, - arguments: &[Expr], + position: Option, + arguments: &[&Expr], ) -> Result { let mut values = Vec::with_capacity(arguments.len()); for a in arguments { @@ -1161,7 +1191,7 @@ fn apply_lambda( /// int slot, and the second call printed a pointer as a number. A generic /// lambda is specialised by its ARGUMENTS at each call site instead, exactly as /// a generic function is ([`crate::genfn`], [TYPE-GENERICS-FN]). -pub(crate) fn inline_sig(cg: &Codegen, position: Option) -> Option { +pub(crate) fn inline_sig(cg: &Codegen, position: Option) -> Option { cg.prog .lambda_type(position) .filter(|t| crate::types::fn_value_concrete(t)) @@ -1176,7 +1206,7 @@ pub(crate) fn apply_lambda_values( body: &Expr, values: Vec, sig: Option<&FnSig>, - position: Option, + position: Option, ) -> Result { reduce_lambda(cg, parameters, body, values, sig, &[], position) } @@ -1192,7 +1222,7 @@ pub(crate) fn reduce_lambda( values: Vec, sig: Option<&FnSig>, rest: &[crate::curry::ArgGroup<'_>], - position: Option, + position: Option, ) -> Result { cg.push_scope(); // `fn_ptr_locals` is per-FUNCTION, not per-scope ([`Codegen::begin_function`]), @@ -1220,7 +1250,7 @@ fn bind_lambda_params( parameters: &[Parameter], values: Vec, sig: Option<&FnSig>, - position: Option, + position: Option, ) -> Result<()> { let declared = cg.prog.lambda_type(position).cloned(); for (index, (p, v)) in parameters.iter().zip(values).enumerate() { @@ -1308,7 +1338,7 @@ fn call_builtin_with_values(cg: &mut Codegen, name: &str, args: &[Value]) -> Opt "toString" => to_string_value(cg, arg()), // [BUILTIN-TOFLOAT] [GPU-CONVERT] the canonical float-pipeline seed // `gpuIota(n) |> gpuMap(toFloat)` lowers through this arm. - "toFloat" => as_i64(cg, arg()).and_then(|n| crate::conv::as_double(cg, n)), + "toFloat" => as_i64(cg, arg()).and_then(|n| as_double(cg, n)), "abs" => gen_unary_propagating(cg, arg(), gen_abs_value), _ => return None, }) @@ -1403,7 +1433,12 @@ fn ordered_args( .unwrap_or_default(); let ffi = !cg.fn_params.contains_key(name) && cg.prog.functions.contains_key(name); if !named.is_empty() { - if let Some(pnames) = cg.fn_params.get(name).cloned() { + if let Some(pnames) = cg + .fn_params + .get(name) + .or_else(|| cg.extern_params.get(name)) + .cloned() + { let mut out = Vec::new(); for (i, pn) in pnames.iter().enumerate() { if let Some(argument) = arguments diff --git a/crates/osprey-codegen/src/fiber.rs b/crates/osprey-codegen/src/fiber.rs index ce29bda1..93e1cf02 100644 --- a/crates/osprey-codegen/src/fiber.rs +++ b/crates/osprey-codegen/src/fiber.rs @@ -122,7 +122,7 @@ pub(crate) fn gen_send(cg: &mut Codegen, channel: &Expr, value: &Expr) -> Result let id = as_i64(cg, ch)?; let v = gen_expr(cg, value)?; if v.result_inner.is_some() { - return Err(crate::error::CodegenError::unsupported( + return Err(CodegenError::unsupported( "Result-valued channels are not yet represented losslessly; handle the Result before sending", )); } @@ -241,9 +241,7 @@ pub(crate) fn gen_builtin(cg: &mut Codegen, name: &str, args: &[Expr]) -> Result // [CONCURRENCY-YIELD]. "fiberDone" => { let Some(a) = args.first() else { - return Err(crate::error::CodegenError::invalid( - "fiberDone needs a fiber argument", - )); + return Err(CodegenError::invalid("fiberDone needs a fiber argument")); }; let v = gen_expr(cg, a)?; let id = as_i64(cg, v)?; diff --git a/crates/osprey-codegen/src/gpu.rs b/crates/osprey-codegen/src/gpu.rs index 4c434644..b254ac32 100644 --- a/crates/osprey-codegen/src/gpu.rs +++ b/crates/osprey-codegen/src/gpu.rs @@ -186,8 +186,7 @@ fn buffer_literal( /// buffer sized at the *source* length, because the kept count is not known /// until the loop has run. fn kept_counter(cg: &mut Codegen) -> String { - let kept = cg.fresh_reg(); - cg.emit(format!("{kept} = alloca i64")); + let kept = cg.emit_reg("alloca i64"); cg.emit(format!("store i64 0, i64* {kept}")); kept } diff --git a/crates/osprey-codegen/src/gpu_kernel.rs b/crates/osprey-codegen/src/gpu_kernel.rs index 3134a351..af315636 100644 --- a/crates/osprey-codegen/src/gpu_kernel.rs +++ b/crates/osprey-codegen/src/gpu_kernel.rs @@ -388,7 +388,7 @@ mod tests { /// The parsed mode, or the rendered error — assertable without requiring /// `PartialEq` on the codegen error type. - fn parsed(value: Option<&str>) -> std::result::Result { + fn parsed(value: Option<&str>) -> Result { mode_of(value).map_err(|e| e.to_string()) } diff --git a/crates/osprey-codegen/src/iter.rs b/crates/osprey-codegen/src/iter.rs index 4e5305be..fad8b62a 100644 --- a/crates/osprey-codegen/src/iter.rs +++ b/crates/osprey-codegen/src/iter.rs @@ -186,8 +186,7 @@ fn branch_on_predicate(cg: &mut Codegen, cb: &Callback, elem: Value) -> Result<( let pred = invoke(cg, cb, vec![elem])?; let pred = crate::cast::coerce_to(cg, pred, LType::I1)?; let pb = as_i64(cg, pred)?; - let nz = cg.fresh_reg(); - cg.emit(format!("{nz} = icmp ne i64 {}, 0", pb.operand)); + let nz = cg.emit_reg(format!("icmp ne i64 {}, 0", pb.operand)); let taken = cg.fresh_label(); let rejected = cg.fresh_label(); cg.emit(format!("br i1 {nz}, label %{taken}, label %{rejected}")); @@ -258,8 +257,7 @@ pub(crate) fn acc_init(cg: &mut Codegen, args: &[Expr]) -> Result<(String, Value crate::arc::escape_retain(cg, &initial); let tmpl = initial.clone(); let boxed = box_to_i64(cg, initial); - let acc = cg.fresh_reg(); - cg.emit(format!("{acc} = alloca i64")); + let acc = cg.emit_reg("alloca i64"); cg.emit(format!("store i64 {}, i64* {acc}", boxed.operand)); Ok((acc, tmpl)) } @@ -409,7 +407,7 @@ fn list_builder(cg: &mut Codegen, args: &[Expr], filter: bool) -> Result } let mapped = invoke(cg, &f, vec![elem])?; if mapped.result_inner.is_some() { - return Err(crate::error::CodegenError::unsupported( + return Err(CodegenError::unsupported( "mapList cannot store an unhandled Result element; handle it in the callback", )); } diff --git a/crates/osprey-codegen/src/lib.rs b/crates/osprey-codegen/src/lib.rs index 0871c1f9..45cb7149 100644 --- a/crates/osprey-codegen/src/lib.rs +++ b/crates/osprey-codegen/src/lib.rs @@ -50,6 +50,9 @@ mod runtime; mod stmt; mod strings; mod testing; +#[cfg(test)] +#[path = "../../testkit.rs"] +mod testkit; mod types; pub use error::{CodegenError, Result}; @@ -98,6 +101,7 @@ fn stmt_idents(s: &osprey_ast::Stmt, out: &mut std::collections::BTreeSet String { @@ -162,10 +166,15 @@ mod tests { #[test] fn emits_main_and_puts_for_hello() { let ir = module("print(\"hello\")\n"); - assert!(ir.contains("define i32 @main() #0")); - assert!(ir.contains("declare i32 @puts(i8*)")); - assert!(ir.contains("call i32 @puts")); - assert!(ir.contains("hello\\00")); + shows( + &ir, + &[ + "define i32 @main() #0", + "declare i32 @puts(i8*)", + "call i32 @puts", + "hello\\00", + ], + ); // Every function keeps frame pointers so the sampling profiler's // FP-chain walk is valid from any pc [PROF-CODEGEN-FP]. assert!(ir.contains("attributes #0 = { \"frame-pointer\"=\"all\" }")); @@ -196,11 +205,16 @@ mod tests { #[test] fn testing_builtins_lower_to_tap_runtime_calls() { let ir = module("test(\"adds\", fn() => expect(1 + 1, 2))\n"); - assert!(ir.contains("call i32 @osp_test_begin(i8*")); - assert!(ir.contains("call void @osp_test_end(i8*")); - assert!(ir.contains("call void @osp_test_assert(i8* null, i32")); - assert!(ir.contains("call i32 @osp_test_finalize()")); - assert!(ir.contains("call i32 @strcmp(i8*")); + shows( + &ir, + &[ + "call i32 @osp_test_begin(i8*", + "call void @osp_test_end(i8*", + "call void @osp_test_assert(i8* null, i32", + "call i32 @osp_test_finalize()", + "call i32 @strcmp(i8*", + ], + ); } #[test] @@ -269,8 +283,10 @@ mod tests { // [TESTING-EQUALITY] a Result operand branches on its discriminant: // Success renders bare, Error renders as Error(). let ir = module("expect(intDiv(1, 0), 2)\n"); - assert!(ir.contains("call void @osp_test_assert(i8* null, i32")); - assert!(ir.contains("Error(%s)")); + shows( + &ir, + &["call void @osp_test_assert(i8* null, i32", "Error(%s)"], + ); // A list/map/record operand has no canonical rendering — loud error. assert!(compile_err("expect([1, 2], [1, 3])\n") .to_string() @@ -308,23 +324,33 @@ mod tests { ); let expected_dwarf_version = if cfg!(target_os = "macos") { 4 } else { 5 }; - assert!(ir.contains("source_filename = \"/tmp/debug.osp\"")); - assert!(ir.contains("!llvm.dbg.cu = !{!")); - assert!(ir.contains("!llvm.module.flags = !{!")); - assert!(ir.contains("!DICompileUnit(")); - assert!(ir.contains("!DIFile(filename: \"debug.osp\", directory: \"/tmp\")")); - assert!(ir.contains(&format!("!\"Dwarf Version\", i32 {expected_dwarf_version}"))); - assert!(ir.contains("!DISubprogram(name: \"add\"")); - assert!(ir.contains("!DISubprogram(name: \"main\"")); - assert!(ir.contains("!DILocalVariable(name: \"x\"")); + shows( + &ir, + &[ + "source_filename = \"/tmp/debug.osp\"", + "!llvm.dbg.cu = !{!", + "!llvm.module.flags = !{!", + "!DICompileUnit(", + "!DIFile(filename: \"debug.osp\", directory: \"/tmp\")", + &format!("!\"Dwarf Version\", i32 {expected_dwarf_version}"), + "!DISubprogram(name: \"add\"", + "!DISubprogram(name: \"main\"", + "!DILocalVariable(name: \"x\"", + ], + ); // Parameters (a, b) use dbg.value — SSA args live for the whole // function. `let` locals (x) use dbg.declare over a stack slot, the // robust -O0 representation that keeps the line table free of stray // line-0 rows. [DEBUGGER-DBG-DECLARE] - assert!(ir.contains("@llvm.dbg.value")); - assert!(ir.contains("call void @llvm.dbg.declare(metadata")); - assert!(ir.contains("!DILocation(line: 2, column: 1")); - assert!(ir.contains(", !dbg !")); + shows( + &ir, + &[ + "@llvm.dbg.value", + "call void @llvm.dbg.declare(metadata", + "!DILocation(line: 2, column: 1", + ", !dbg !", + ], + ); } #[test] @@ -466,9 +492,14 @@ mod tests { let r = apply(value: 10, f: fn(x: int) => (x + 1) ?: x)\n\ print(\"r=${r}\")\n", ); - assert!(ir.contains("define i64 @__closure_fn_0(i8* %__env, i64 %$p0)")); - assert!(ir.contains("@__closure_cell_0 = private unnamed_addr constant { i8* }")); - assert!(ir.contains("call i64 %")); + shows( + &ir, + &[ + "define i64 @__closure_fn_0(i8* %__env, i64 %$p0)", + "@__closure_cell_0 = private unnamed_addr constant { i8* }", + "call i64 %", + ], + ); } #[test] @@ -484,16 +515,20 @@ mod tests { print(\"r=${add5(3)}\")\n\ }\n", ); - assert!(ir.contains("define i8* @makeAdder(i64 %$p0)")); - assert!(ir.contains("bitcast i8* %__env to { i8*, i64 }*")); - assert!(ir.contains("call i8* @osp_alloc")); + shows( + &ir, + &[ + "define i8* @makeAdder(i64 %$p0)", + "bitcast i8* %__env to { i8*, i64 }*", + "call i8* @osp_alloc", + ], + ); } #[test] fn interpolation_uses_sprintf() { let ir = module("let x = 7\nprint(\"x=${x}\")\n"); - assert!(ir.contains("@sprintf")); - assert!(ir.contains("@osp_alloc")); + shows(&ir, &["@sprintf", "@osp_alloc"]); } /// An erasure builds a shape-carrying box, and ownership crosses it in @@ -613,9 +648,7 @@ mod tests { #[test] fn match_lowers_to_phi() { let ir = module("fn pick(a: int, b: int) -> int = match a < b { true => a false => b }\n"); - assert!(ir.contains("icmp")); - assert!(ir.contains("br i1")); - assert!(ir.contains("phi i64")); + shows(&ir, &["icmp", "br i1", "phi i64"]); } #[test] @@ -625,6 +658,15 @@ mod tests { // return type is `{ i64, i8 }*`; what matters here is the argument order. let ir = module("fn sub(a, b) = a - b\nlet r = sub(b: 1, a: 9)\n"); assert!(ir.contains("@sub(i64 9, i64 1)")); + let external = module( + "extern fn takeFirst(first: int, second: int) -> int\n\ + fn namedWitness() -> int = takeFirst(second: 22, first: 11)\n", + ); + assert!( + function_body(&external, "define i64 @namedWitness()") + .contains("@takeFirst(i64 11, i64 22)"), + "extern calls must preserve declaration order and the C ABI:\n{external}" + ); } #[test] @@ -687,9 +729,7 @@ mod tests { print(\"sum=${s}\")\n\ }\n", ); - assert!(ir.contains("@osp_alloc")); - assert!(ir.contains("icmp ne i64")); - assert!(ir.contains("alloca i64")); + shows(&ir, &["@osp_alloc", "icmp ne i64", "alloca i64"]); } #[test] @@ -710,9 +750,14 @@ mod tests { print(\"len=${listLength(m)} f=${listLength(f)} t=${t}\")\n\ }\n", ); - assert!(ir.contains("osprey_list_builder_new")); - assert!(ir.contains("osprey_list_builder_push")); - assert!(ir.contains("osprey_list_builder_seal")); + shows( + &ir, + &[ + "osprey_list_builder_new", + "osprey_list_builder_push", + "osprey_list_builder_seal", + ], + ); } #[test] @@ -756,8 +801,7 @@ mod tests { print(\"r=${g()}\")\n\ }\n", ); - assert!(ir.contains("call i8* @osp_alloc")); - assert!(ir.contains("bitcast i8* %__env")); + shows(&ir, &["call i8* @osp_alloc", "bitcast i8* %__env"]); } #[test] @@ -813,8 +857,7 @@ mod tests { }\n\ fn main() -> Unit = print(\"a=${area(Circle { r: 3 })}\")\n", ); - assert!(ir.contains("load i64, i64*")); - assert!(ir.contains("icmp eq i64")); + shows(&ir, &["load i64, i64*", "icmp eq i64"]); assert_eq!( ir.matches("call { i64, i1 } @llvm.smul.with.overflow.i64") .count(), @@ -921,8 +964,7 @@ mod tests { print(\"r=${first(V { a: 10, b: 20 })}\")\n", ); // The field bind loads slot 1 of the block, reached via the tag compare. - assert!(ir.contains("load i64, i64*")); - assert!(ir.contains("icmp eq i64")); + shows(&ir, &["load i64, i64*", "icmp eq i64"]); } #[test] @@ -942,10 +984,15 @@ mod tests { print(classify(xs))\n\ }\n", ); - assert!(ir.contains("osprey_list_length")); - assert!(ir.contains("osprey_list_get")); - assert!(ir.contains("osprey_list_drop")); - assert!(ir.contains("icmp sge i64")); + shows( + &ir, + &[ + "osprey_list_length", + "osprey_list_get", + "osprey_list_drop", + "icmp sge i64", + ], + ); } #[test] @@ -1012,9 +1059,14 @@ mod tests { let wrapped = choose(7)\n\ print(\"${failed}:${wrapped}\")\n", ); - assert!(closure.contains("define i64 @__closure_fn_")); - assert!(closure.contains("i8* %__env, i8* %$p0")); - assert!(closure.contains("bitcast i8* %$p0 to { i64, i8, i8* }*")); + shows( + &closure, + &[ + "define i64 @__closure_fn_", + "i8* %__env, i8* %$p0", + "bitcast i8* %$p0 to { i64, i8, i8* }*", + ], + ); } /// Matching a bare scalar against `Success`/`Error` arms takes the Success @@ -1106,11 +1158,16 @@ mod tests { print(\"${join(ws, \"-\")} ${listLength(ls)}\")\n\ }\n", ); - assert!(ir.contains("@osp_strlen")); - assert!(ir.contains("osp_string_to_upper")); - assert!(ir.contains("osp_parse_int_strict")); - assert!(ir.contains("osp_string_codepoint_at")); - assert!(ir.contains("osp_string_join")); + shows( + &ir, + &[ + "@osp_strlen", + "osp_string_to_upper", + "osp_parse_int_strict", + "osp_string_codepoint_at", + "osp_string_join", + ], + ); } // ---- collections: map literals, map operations ---- @@ -1131,10 +1188,15 @@ mod tests { match m[\"a\"] { Success { value } => print(\"i=${value}\") Error { message } => print(\"no\") }\n\ }\n", ); - assert!(ir.contains("osprey_map_builder_new")); - assert!(ir.contains("osprey_map_set")); - assert!(ir.contains("osprey_map_remove")); - assert!(ir.contains("osprey_map_iter_new")); + shows( + &ir, + &[ + "osprey_map_builder_new", + "osprey_map_set", + "osprey_map_remove", + "osprey_map_iter_new", + ], + ); } #[test] @@ -1250,8 +1312,7 @@ mod tests { match listGet(xs, 0) { Success { value } => print(\"v=${value}\") Error { message } => print(\"no\") }\n\ }\n", ); - assert!(ir.contains("osprey_list_in_bounds")); - assert!(ir.contains("@strcmp")); + shows(&ir, &["osprey_list_in_bounds", "@strcmp"]); } // ---- algebraic effects: handler-owned state (effects.rs) ---- @@ -1392,8 +1453,13 @@ mod tests { fn main() -> int { mut c = 0\n let r = handle State get => c set v => { c = v } in bump()\n print(\"r=${toString(r)} c=${toString(c)}\")\n 0 }\n", ); // env-carrying handler ABI (push takes a 4th i8* env; perform resolves it) - assert!(ir.contains("declare i32 @__osprey_handler_push(i8*, i8*, i8*, i8*)")); - assert!(ir.contains("@__osprey_handler_lookup_env")); + shows( + &ir, + &[ + "declare i32 @__osprey_handler_push(i8*, i8*, i8*, i8*)", + "@__osprey_handler_lookup_env", + ], + ); // the captured `mut` became a heap cell (malloc'd, stored, loaded) assert!(ir.contains("@osp_alloc")); // each arm is emitted with the hidden leading env parameter @@ -1437,8 +1503,7 @@ mod tests { "fn greet(n: string) -> string = \"hi ${n}\"\n\ fn main() -> Unit = print(await(spawn greet(\"x\")))\n", ); - assert!(ir.contains("fiber_await")); - assert!(ir.contains("inttoptr i64")); + shows(&ir, &["fiber_await", "inttoptr i64"]); assert!( ir.lines() .any(|line| line.contains("@fiber_spawn_env_owned") && line.ends_with(", i64 1)")), @@ -1507,10 +1572,7 @@ mod tests { print(\"${mixed} ${q} ${neg} ${negi} ${lt} ${m}\")\n\ }\n", ); - assert!(ir.contains("sitofp i64")); - assert!(ir.contains("fdiv double")); - assert!(ir.contains("fneg double")); - assert!(ir.contains("fcmp")); + shows(&ir, &["sitofp i64", "fdiv double", "fneg double", "fcmp"]); } #[test] @@ -1526,9 +1588,7 @@ mod tests { print(\"${c} ${d} ${e}\")\n\ }\n", ); - assert!(ir.contains("and i1")); - assert!(ir.contains("or i1")); - assert!(ir.contains("xor i1")); + shows(&ir, &["and i1", "or i1", "xor i1"]); } // ---- records / aggregate (aggregate.rs) ---- @@ -1545,8 +1605,7 @@ mod tests { print(\"${p.x} ${p.y} ${p2.x}\")\n\ }\n", ); - assert!(ir.contains("getelementptr")); - assert!(ir.contains("store i64")); + shows(&ir, &["getelementptr", "store i64"]); } #[test] @@ -1584,10 +1643,15 @@ card doc index selected = print(\"${got} ${y} ${z} ${await(f)} ${fiberDone(f)}\")\n\ }\n", ); - assert!(ir.contains("channel_create")); - assert!(ir.contains("channel_send")); - assert!(ir.contains("channel_recv")); - assert!(ir.contains("fiber_done")); + shows( + &ir, + &[ + "channel_create", + "channel_send", + "channel_recv", + "fiber_done", + ], + ); } #[test] @@ -1639,6 +1703,16 @@ card doc index selected = // from the type table and dispatch through the closure cell. let ir = module( "type Cfg = { keep: (int) -> bool }\n\ + type Dispatch = Dispatch { m: () -> string }\n\ + fn methodField() -> string = \"field\"\n\ + fn m(receiver: T) -> int = 31\n\ + fn dispatch(receiver: T) = receiver.m()\n\ + fn echo(receiver: T) -> T = receiver\n\ + fn deferEcho(receiver: T) = receiver.echo()\n\ + fn explicitWitness() -> int = 5.echo()\n\ + fn deferredWitness() -> int = deferEcho(7)\n\ + fn fallbackWitness() -> int = dispatch(9)\n\ + fn fieldWitness() -> string = dispatch(Dispatch { m: methodField })\n\ fn add3(a: int) -> (int) -> (int) -> int =\n\ fn(b: int) => fn(c: int) => (a + b + c) ?: a\n\ fn makeAdder(n: int) -> (int) -> int = fn(x: int) => (x + n) ?: x\n\ @@ -1647,11 +1721,86 @@ card doc index selected = let chain = add3(1)(2)(3)\n\ let computed = fold(map(range(1, 4), makeAdder(10)), 0, fn(a: int, b: int) => (a + b) ?: a)\n\ let fieldcb = fold(filter(range(1, 5), cfg.keep), 0, fn(a: int, b: int) => (a + b) ?: a)\n\ - print(\"${chain} ${computed} ${fieldcb}\")\n\ + print(\"${chain} ${computed} ${fieldcb} ${explicitWitness()} ${deferredWitness()} ${fallbackWitness()} ${fieldWitness()}\")\n\ }\n", ); // Each higher-order callee loads a function pointer from a closure cell. assert!(ir.contains("to { i8* }*"), "expected a closure cell-call"); + for (name, value) in [ + ("explicitWitness", 5), + ("deferredWitness", 7), + ("fallbackWitness", 31), + ] { + assert!( + function_body(&ir, &format!("define i64 @{name}()")) + .contains(&format!("ret i64 {value}")), + "{name} must return its selected generic function's value:\n{ir}" + ); + } + assert!( + function_body(&ir, "define i8* @fieldWitness()").contains("call i8* %"), + "the callable record field must retain its string-returning ABI:\n{ir}" + ); + + // A field callback returns another callable through two generic helpers. + // The second record also proves named field arguments keep written slots. + let returned = module( + "effect Probe { value: fn() -> int }\n\ + fn fetch() -> int !Probe = perform Probe.value()\n\ + fn pure() -> int = 22\n\ + type Factory = Factory { m: () -> () -> int }\n\ + type NamedFactory = NamedFactory { m: (() -> int, () -> int) -> () -> int }\n\ + fn pureFactory() -> () -> int = pure\n\ + fn effectFactory() -> () -> int = fetch\n\ + fn firstCallback(callback: () -> int, ignored: () -> int) -> () -> int = callback\n\ + fn secondCallback(callback: () -> int, ignored: () -> int) -> () -> int = ignored\n\ + fn m(x: T) -> () -> int = pure\n\ + fn dispatch(x: T) = x.m()\n\ + fn dispatchNamed(x: T) = x.m(ignored: pure, callback: fetch)\n\ + fn forward(dummy: T, cb: () -> () -> int) = dispatch(Factory { m: cb })()\n\ + fn forwardNamed(dummy: T, cb: (() -> int, () -> int) -> () -> int) = dispatchNamed(NamedFactory { m: cb })()\n\ + fn firstSlot(first: int, second: int) -> int = first\n\ + fn throughSlot(dummy: T, callback: (int, int) -> int) = callback(second: 22, first: 11)\n\ + fn genericSlotWitness() -> int = throughSlot(0, firstSlot)\n\ + fn declaredSlotWitness() -> int = firstSlot(second: 22, first: 11)\n\ + fn directLambdaWitness() -> int = (fn(first: int, second: int) => first)(second: 22, first: 11)\n\ + fn throughLambda(unused: T) = (fn(first: int, second: int) => first)(second: 22, first: 11)\n\ + fn genericLambdaWitness() -> int = throughLambda(0)\n\ + fn pureWitness() -> int = forward(0, pureFactory)\n\ + fn namedPureWitness() -> int = forwardNamed(0, firstCallback)\n\ + fn handledWitness() -> int = handle Probe value => 33 in forward(0, effectFactory)\n\ + fn namedHandledWitness() -> int = handle Probe value => 33 in forwardNamed(0, secondCallback)\n\ + print(\"${pureWitness()} ${namedPureWitness()} ${handledWitness()} ${namedHandledWitness()} ${genericSlotWitness()} ${declaredSlotWitness()} ${directLambdaWitness()} ${genericLambdaWitness()}\")\n", + ); + for witness in ["pureWitness", "namedPureWitness"] { + let body = function_body(&returned, &format!("define i64 @{witness}()")); + assert!( + body.contains("call i8* %") && body.contains("call i64 %"), + "{witness} must call the factory and then its returned int callback:\n{returned}" + ); + } + assert!( + returned.contains("@__osprey_handler_push") + && returned.contains("@__osprey_handler_lookup_env"), + "returned effectful callbacks must retain their dynamic handler:\n{returned}" + ); + for (witness, arguments) in [ + ("genericSlotWitness", "i64 22, i64 11"), + ("declaredSlotWitness", "i64 11, i64 22"), + ] { + assert!( + function_body(&returned, &format!("define i64 @{witness}()")) + .contains(&format!("@firstSlot({arguments})")), + "{witness} must preserve its source call site's argument slots:\n{returned}" + ); + } + for witness in ["directLambdaWitness", "genericLambdaWitness"] { + assert!( + function_body(&returned, &format!("define i64 @{witness}()")) + .contains("ret i64 22"), + "{witness} must bind named values in written slots:\n{returned}" + ); + } } #[test] @@ -1784,8 +1933,7 @@ card doc index selected = print(\"${listLength(fs)} ${listLength(bs)}\")\n\ }\n", ); - assert!(ir.contains("bitcast double")); - assert!(ir.contains("zext i1")); + shows(&ir, &["bitcast double", "zext i1"]); } #[test] @@ -1799,8 +1947,7 @@ card doc index selected = print(\"${a == b}\")\n\ }\n", ); - assert!(ir.contains("zext i1")); - assert!(ir.contains("icmp eq i64")); + shows(&ir, &["zext i1", "icmp eq i64"]); } #[test] @@ -1814,8 +1961,7 @@ card doc index selected = print(\"${gt}\")\n\ }\n", ); - assert!(ir.contains("sitofp i64")); - assert!(ir.contains("fcmp")); + shows(&ir, &["sitofp i64", "fcmp"]); } #[test] @@ -1856,8 +2002,8 @@ card doc index selected = fn codegen_constructors_are_callable_directly() { // builder.rs Codegen::new + Default (not used by compile_program, which // takes inferred types) — exercised directly for the public surface. - let _a = crate::builder::Codegen::new(); - let _b = crate::builder::Codegen::default(); + let _a = builder::Codegen::new(); + let _b = builder::Codegen::default(); } // ---- GPU kernel extraction [GPU-KERNEL-EXTRACT] ---- @@ -1904,8 +2050,13 @@ card doc index selected = print(f())\n", ); assert_eq!(ir.matches(KERNEL_PREFIX).count(), 4, "{ir}"); - assert!(ir.contains("define double @__gpu_kernel_0(double %$p0)")); - assert!(ir.contains("define double @__gpu_kernel_1(double %$p0)")); + shows( + &ir, + &[ + "define double @__gpu_kernel_0(double %$p0)", + "define double @__gpu_kernel_1(double %$p0)", + ], + ); } #[test] @@ -1925,8 +2076,7 @@ card doc index selected = let header = "define double @__gpu_kernel_0(double %$p0, double %$p1, double %$p2)"; assert!(ir.contains(header), "{ir}"); let kernel = function_body(&ir, header); - assert!(kernel.contains("fmul double %$p1, %$p2"), "{kernel}"); - assert!(kernel.contains("fadd double"), "{kernel}"); + shows(&kernel, &["fmul double %$p1, %$p2", "fadd double"]); assert!(!kernel.contains("__env"), "{kernel}"); let host = function_body(&ir, "define i64 @f()"); assert!( @@ -1963,8 +2113,7 @@ card doc index selected = let header = "define double @__gpu_kernel_0(double %$p0, double %$p1, double %$p2)"; assert!(ir.contains(header), "{ir}"); let kernel = function_body(&ir, header); - assert!(kernel.contains("fmul double %$p0, %$p2"), "{kernel}"); - assert!(kernel.contains("fadd double %$p1,"), "{kernel}"); + shows(&kernel, &["fmul double %$p0, %$p2", "fadd double %$p1,"]); } /// A handler with one RESUMING arm and one SUBSTITUTING arm continues by diff --git a/crates/osprey-codegen/src/listlit.rs b/crates/osprey-codegen/src/listlit.rs index eaf7f5e2..35f293cc 100644 --- a/crates/osprey-codegen/src/listlit.rs +++ b/crates/osprey-codegen/src/listlit.rs @@ -143,16 +143,14 @@ pub(crate) fn gen_list( let elem_owner = first.osp_ty.clone(); let n = elements.len(); let data = cg.heap_alloc(&(n * 8).to_string()); - let arr = cg.fresh_reg(); - cg.emit(format!("{arr} = bitcast i8* {data} to {}*", elem.as_str())); + let arr = cg.emit_reg(format!("bitcast i8* {data} to {}*", elem.as_str())); for (i, v) in vals.into_iter().enumerate() { let v = coerce_to(cg, v, elem)?; // The header's drop releases pointer elements, so each store is a new // reference [GC-ARC-PERCEUS]. crate::arc::dup_store(cg, elem.as_str(), &v.operand); - let slot = cg.fresh_reg(); - cg.emit(format!( - "{slot} = getelementptr {}, {}* {arr}, i64 {i}", + let slot = cg.emit_reg(format!( + "getelementptr {}, {}* {arr}, i64 {i}", elem.as_str(), elem.as_str() )); @@ -259,7 +257,7 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result .as_deref() .is_some_and(crate::collections::is_map_owner) { - let key = crate::cast::coerce_to(cg, iv, LType::Str)?; + let key = coerce_to(cg, iv, LType::Str)?; let k = crate::conv::box_to_i64(cg, key); return crate::collections::runtime_map_get(cg, &tv, &k); } @@ -285,36 +283,23 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result let data = crate::aggregate::load_field(cg, LIST_STRUCT, &tv.operand, 1, LType::Str); // bounds: 0 <= idx < length - let ge0 = cg.fresh_reg(); - cg.emit(format!("{ge0} = icmp sge i64 {}, 0", idx.operand)); - let lt = cg.fresh_reg(); - cg.emit(format!("{lt} = icmp slt i64 {}, {len}", idx.operand)); - let ok = cg.fresh_reg(); - cg.emit(format!("{ok} = and i1 {ge0}, {lt}")); + let ge0 = cg.emit_reg(format!("icmp sge i64 {}, 0", idx.operand)); + let lt = cg.emit_reg(format!("icmp slt i64 {}, {len}", idx.operand)); + let ok = cg.emit_reg(format!("and i1 {ge0}, {lt}")); // Load only on the in-bounds path — the OOB / empty (`data == null`) path // must not dereference. - let load_bb = cg.fresh_label(); - let oob_bb = cg.fresh_label(); - let cont = cg.fresh_label(); - cg.emit(format!("br i1 {ok}, label %{load_bb}, label %{oob_bb}")); + let (load_bb, oob_bb, cont) = cg.diamond(&ok); cg.start_block(&load_bb); - let arr = cg.fresh_reg(); - cg.emit(format!("{arr} = bitcast i8* {data} to {}*", elem.as_str())); - let slot = cg.fresh_reg(); - cg.emit(format!( - "{slot} = getelementptr {}, {}* {arr}, i64 {}", + let arr = cg.emit_reg(format!("bitcast i8* {data} to {}*", elem.as_str())); + let slot = cg.emit_reg(format!( + "getelementptr {}, {}* {arr}, i64 {}", elem.as_str(), elem.as_str(), idx.operand )); - let val = cg.fresh_reg(); - cg.emit(format!( - "{val} = load {}, {}* {slot}", - elem.as_str(), - elem.as_str() - )); + let val = cg.emit_reg(format!("load {}, {}* {slot}", elem.as_str(), elem.as_str())); cg.emit(format!("br label %{cont}")); cg.start_block(&oob_bb); @@ -322,13 +307,11 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result cg.start_block(&cont); let zero = crate::llty::zero_literal(elem); - let phi = cg.fresh_reg(); - cg.emit(format!( - "{phi} = phi {} [ {val}, %{load_bb} ], [ {zero}, %{oob_bb} ]", + let phi = cg.emit_reg(format!( + "phi {} [ {val}, %{load_bb} ], [ {zero}, %{oob_bb} ]", elem.as_str() )); - let disc = cg.fresh_reg(); - cg.emit(format!("{disc} = select i1 {ok}, i8 0, i8 1")); + let disc = cg.emit_reg(format!("select i1 {ok}, i8 0, i8 1")); // `ok` is the in-bounds flag, so the message is selected on the failing path. let oob = cg.string_constant(crate::collections::INDEX_OOB); let errmsg = cg.emit_reg(format!("select i1 {ok}, i8* null, i8* {}", oob.operand)); diff --git a/crates/osprey-codegen/src/llty.rs b/crates/osprey-codegen/src/llty.rs index bf8b5b2f..32811264 100644 --- a/crates/osprey-codegen/src/llty.rs +++ b/crates/osprey-codegen/src/llty.rs @@ -196,7 +196,7 @@ impl fmt::Display for LType { /// (`null` when Success or when the producer set no message). The single source /// of truth for the Result ABI layout — every builder/reader spells it via here. #[must_use] -pub fn result_struct_ty(inner: LType) -> String { +pub(crate) fn result_struct_ty(inner: LType) -> String { format!("{{ {inner}, i8, i8* }}") } diff --git a/crates/osprey-codegen/src/loops.rs b/crates/osprey-codegen/src/loops.rs index f131c418..87d288cd 100644 --- a/crates/osprey-codegen/src/loops.rs +++ b/crates/osprey-codegen/src/loops.rs @@ -21,8 +21,7 @@ pub(crate) struct Counter { } fn open_counter(cg: &mut Codegen, start: &str, bound: &str) -> Counter { - let slot = cg.fresh_reg(); - cg.emit(format!("{slot} = alloca i64")); + let slot = cg.emit_reg("alloca i64"); cg.emit(format!("store i64 {start}, i64* {slot}")); let cond = cg.fresh_label(); let body = cg.fresh_label(); @@ -31,10 +30,8 @@ fn open_counter(cg: &mut Codegen, start: &str, bound: &str) -> Counter { cg.emit(format!("br label %{cond}")); cg.start_block(&cond); - let i = cg.fresh_reg(); - cg.emit(format!("{i} = load i64, i64* {slot}")); - let more = cg.fresh_reg(); - cg.emit(format!("{more} = icmp slt i64 {i}, {bound}")); + let i = cg.emit_reg(format!("load i64, i64* {slot}")); + let more = cg.emit_reg(format!("icmp slt i64 {i}, {bound}")); cg.emit(format!("br i1 {more}, label %{body}, label %{endl}")); cg.start_block(&body); diff --git a/crates/osprey-codegen/src/lower.rs b/crates/osprey-codegen/src/lower.rs index c7646ee2..164fd0f1 100644 --- a/crates/osprey-codegen/src/lower.rs +++ b/crates/osprey-codegen/src/lower.rs @@ -236,9 +236,20 @@ fn record_declarations(cg: &mut Codegen, program: &Program) { // A union an extern claims to return loses its MASK_DIRECT proof // (builder.rs `field_meta`); record those before any layout lands. Stmt::Extern { - return_type: Some(t), + name, + parameters, + return_type, .. - } => cg.poison_extern_ret(t), + } => { + // Implements [CALL-ARGUMENTS] without changing foreign ABI identity. + let _ = cg.extern_params.insert( + name.clone(), + parameters.iter().map(|p| p.name.clone()).collect(), + ); + if let Some(t) = return_type { + cg.poison_extern_ret(t); + } + } _ => {} } } diff --git a/crates/osprey-codegen/src/pattern.rs b/crates/osprey-codegen/src/pattern.rs index ec633aff..a67b7cf7 100644 --- a/crates/osprey-codegen/src/pattern.rs +++ b/crates/osprey-codegen/src/pattern.rs @@ -380,8 +380,7 @@ fn gen_result_match(cg: &mut Codegen, disc: &Value, arms: &[MatchArm]) -> Result // (cond, success-binding, error-binding) by Result shape. let (cond, succ_val, err_val) = if disc.result_inner.is_some() { let d = crate::result::load_disc(cg, disc); - let c = cg.fresh_reg(); - cg.emit(format!("{c} = icmp eq i8 {d}, 0")); + let c = cg.emit_reg(format!("icmp eq i8 {d}, 0")); // Success binds the value slot; Error binds the errmsg slot (the real // reason), so `Error { message }` sees the message regardless of the // success payload type. Implements [ERR-PAYLOAD]. @@ -420,10 +419,7 @@ fn gen_result_match(cg: &mut Codegen, disc: &Value, arms: &[MatchArm]) -> Result ("true".to_string(), disc.clone(), empty) }; - let sl = cg.fresh_label(); - let el = cg.fresh_label(); - let end = cg.fresh_label(); - cg.emit(format!("br i1 {cond}, label %{sl}, label %{el}")); + let (sl, el, end) = cg.diamond(&cond); let mark = crate::arc::frame_mark(cg); let mut phi_in: Vec<(Value, String)> = Vec::new(); @@ -467,10 +463,8 @@ fn gen_union_match( owner: &str, ) -> Result { // Load the discriminant tag (every variant block starts with `{ i64 tag, … }`). - let tagp = cg.fresh_reg(); - cg.emit(format!("{tagp} = bitcast i8* {} to i64*", disc.operand)); - let tag = cg.fresh_reg(); - cg.emit(format!("{tag} = load i64, i64* {tagp}")); + let tagp = cg.emit_reg(format!("bitcast i8* {} to i64*", disc.operand)); + let tag = cg.emit_reg(format!("load i64, i64* {tagp}")); let end = cg.fresh_label(); let mark = crate::arc::frame_mark(cg); @@ -482,8 +476,7 @@ fn gen_union_match( let name = name.to_string(); let vpos = variants.iter().position(|v| *v == name).unwrap_or(0); let vtag = i64::try_from(vpos).unwrap_or(0); - let cond = cg.fresh_reg(); - cg.emit(format!("{cond} = icmp eq i64 {tag}, {vtag}")); + let cond = cg.emit_reg(format!("icmp eq i64 {tag}, {vtag}")); let next_lbl = open_guarded_arm(cg, &cond); bind_variant_fields(cg, disc, &name, &fields, mode); emit_arm_body(cg, arm, &mut phi_in)?; @@ -555,11 +548,7 @@ fn bind_variant_fields( let Some((view, struct_ty)) = bindable_layout(cg, variant, pat_fields) else { return; }; - let src = cg.fresh_reg(); - cg.emit(format!( - "{src} = bitcast i8* {} to {struct_ty}*", - disc.operand - )); + let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", disc.operand)); for (column, bind_name) in pat_fields.iter().enumerate() { if bind_name.is_empty() { continue; // an ignored slot binds nothing @@ -709,8 +698,7 @@ fn finish_phi( .map(|(v, blk)| format!("[ {}, %{blk} ]", v.operand)) .collect::>() .join(", "); - let reg = cg.fresh_reg(); - cg.emit(format!("{reg} = phi {llvm_ty} {incoming}")); + let reg = cg.emit_reg(format!("phi {llvm_ty} {incoming}")); let common = |sel: fn(&Value) -> Option| { let first = sel(first_val); incoming_values diff --git a/crates/osprey-codegen/src/result.rs b/crates/osprey-codegen/src/result.rs index a0d2ae75..af14e764 100644 --- a/crates/osprey-codegen/src/result.rs +++ b/crates/osprey-codegen/src/result.rs @@ -39,14 +39,12 @@ pub(crate) fn make_result( ]); let obj = cg.malloc_struct(&struct_ty, meta); crate::aggregate::store_field(cg, &struct_ty, obj.as_str(), 0, inner, &v.operand); - let dp = cg.fresh_reg(); - cg.emit(format!( - "{dp} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 1" + let dp = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 1" )); cg.emit(format!("store i8 {disc}, i8* {dp}")); - let mp = cg.fresh_reg(); - cg.emit(format!( - "{mp} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 2" + let mp = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 2" )); // The block's drop mask releases the errmsg word too [GC-ARC-PERCEUS]. crate::arc::dup_store(cg, "i8*", errmsg); @@ -100,8 +98,7 @@ pub(crate) fn make_result_if_err_because( msg: Option<&str>, reason: Option<&str>, ) -> Result { - let disc = cg.fresh_reg(); - cg.emit(format!("{disc} = select i1 {is_err}, i8 1, i8 0")); + let disc = cg.emit_reg(format!("select i1 {is_err}, i8 1, i8 0")); let fallback = match msg { Some(m) => cg.string_constant(m).operand, None => NO_MSG.to_string(), @@ -173,10 +170,7 @@ pub(crate) fn result_from_nullable( pub(crate) fn open_result_branch(cg: &mut Codegen, v: &Value) -> (String, String, String) { let d = load_disc(cg, v); let is_succ = cg.emit_reg(format!("icmp eq i8 {d}, 0")); - let sl = cg.fresh_label(); - let el = cg.fresh_label(); - let end = cg.fresh_label(); - cg.emit(format!("br i1 {is_succ}, label %{sl}, label %{el}")); + let (sl, el, end) = cg.diamond(&is_succ); cg.start_block(&sl); (sl, el, end) } @@ -188,13 +182,11 @@ pub(crate) fn load_disc(cg: &mut Codegen, v: &Value) -> String { let Some(struct_ty) = v.result_struct_ty() else { return "1".to_string(); }; - let dp = cg.fresh_reg(); - cg.emit(format!( - "{dp} = getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 1", + let dp = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 1", v.operand )); - let d = cg.fresh_reg(); - cg.emit(format!("{d} = load i8, i8* {dp}")); + let d = cg.emit_reg(format!("load i8, i8* {dp}")); d } @@ -217,13 +209,11 @@ pub(crate) fn load_errmsg(cg: &mut Codegen, v: &Value) -> Value { return Value::new(NO_MSG, LType::Str); }; let struct_ty = result_struct_ty(inner); - let mp = cg.fresh_reg(); - cg.emit(format!( - "{mp} = getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 2", + let mp = cg.emit_reg(format!( + "getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 2", v.operand )); - let raw = cg.fresh_reg(); - cg.emit(format!("{raw} = load i8*, i8** {mp}")); + let raw = cg.emit_reg(format!("load i8*, i8** {mp}")); Value::new(raw, LType::Str) } @@ -256,12 +246,7 @@ pub(crate) fn repack_to_inner(cg: &mut Codegen, v: Value, inner: LType) -> Resul let disc = load_disc(cg, &v); let errmsg = load_errmsg(cg, &v); let is_success = cg.emit_reg(format!("icmp eq i8 {disc}, 0")); - let success = cg.fresh_label(); - let error = cg.fresh_label(); - let end = cg.fresh_label(); - cg.emit(format!( - "br i1 {is_success}, label %{success}, label %{error}" - )); + let (success, error, end) = cg.diamond(&is_success); cg.start_block(&success); let loaded = load_value(cg, &v); diff --git a/crates/osprey-codegen/src/runtime.rs b/crates/osprey-codegen/src/runtime.rs index 0a68d7ba..d18f2778 100644 --- a/crates/osprey-codegen/src/runtime.rs +++ b/crates/osprey-codegen/src/runtime.rs @@ -61,10 +61,7 @@ fn result_string(cg: &mut Codegen, v: &Value, wrap_success: bool) -> Result)`. let msg = crate::result::load_errmsg(cg, v); let isnull = cg.emit_reg(format!("icmp eq i8* {}, null", msg.operand)); - let fl = cg.fresh_label(); - let nl = cg.fresh_label(); - let jl = cg.fresh_label(); - cg.emit(format!("br i1 {isnull}, label %{nl}, label %{fl}")); + let (nl, fl, jl) = cg.diamond(&isnull); cg.start_block(&fl); let with = sprintf_wrap(cg, "Error(%s)", &msg.operand); let fb = cg.cur_block().to_string(); @@ -73,18 +70,14 @@ fn result_string(cg: &mut Codegen, v: &Value, wrap_success: bool) -> Result Valu pub(crate) fn gen_print(cg: &mut Codegen, v: Value) -> Result { let s = to_string_value(cg, v)?; cg.add_extern("declare i32 @puts(i8*)"); - let reg = cg.fresh_reg(); - cg.emit(format!("{reg} = call i32 @puts(i8* {})", s.operand)); + let _ = cg.emit_reg(format!("call i32 @puts(i8* {})", s.operand)); Ok(Value::unit()) } @@ -157,9 +149,8 @@ fn int_to_string(cg: &mut Codegen, v: Value) -> Result { // full i64 on every target; on LP64 (native) it is identical to `%ld`. let fmt = cg.string_constant("%lld"); let buf = cg.heap_alloc(INT_STRING_BYTES); - let tmp = cg.fresh_reg(); - cg.emit(format!( - "{tmp} = call i32 (i8*, i8*, ...) @sprintf(i8* {buf}, i8* {}, i64 {})", + let _ = cg.emit_reg(format!( + "call i32 (i8*, i8*, ...) @sprintf(i8* {buf}, i8* {}, i64 {})", fmt.operand, i.operand )); let v = Value::new(buf, LType::Str); @@ -171,9 +162,8 @@ fn int_to_string(cg: &mut Codegen, v: Value) -> Result { /// that (and NaN/inf) — see `runtime/string_runtime.c`. fn float_to_string(cg: &mut Codegen, v: &Value) -> Value { cg.add_extern("declare i8* @osp_float_to_string(double)"); - let reg = cg.fresh_reg(); - cg.emit(format!( - "{reg} = call i8* @osp_float_to_string(double {})", + let reg = cg.emit_reg(format!( + "call i8* @osp_float_to_string(double {})", v.operand )); let out = Value::new(reg, LType::Str); @@ -184,9 +174,8 @@ fn float_to_string(cg: &mut Codegen, v: &Value) -> Value { fn bool_to_string(cg: &mut Codegen, v: &Value) -> Value { let t = cg.string_constant("true"); let f = cg.string_constant("false"); - let reg = cg.fresh_reg(); - cg.emit(format!( - "{reg} = select i1 {}, i8* {}, i8* {}", + let reg = cg.emit_reg(format!( + "select i1 {}, i8* {}, i8* {}", v.operand, t.operand, f.operand )); Value::new(reg, LType::Str) diff --git a/crates/osprey-codegen/src/stmt.rs b/crates/osprey-codegen/src/stmt.rs index 71e220ff..a12fa4dd 100644 --- a/crates/osprey-codegen/src/stmt.rs +++ b/crates/osprey-codegen/src/stmt.rs @@ -408,7 +408,7 @@ fn captures_callee_params(cg: &Codegen, value: &Expr) -> bool { let Some((callee_params, _, body, _)) = generic_returned_lambda(cg, value) else { return false; }; - let mut free = std::collections::BTreeSet::new(); + let mut free = BTreeSet::new(); osprey_ast::freevars::free_idents(&body, &mut free); callee_params.iter().any(|p| free.contains(&p.name)) } diff --git a/crates/osprey-codegen/src/strings.rs b/crates/osprey-codegen/src/strings.rs index 737cd6b3..79456327 100644 --- a/crates/osprey-codegen/src/strings.rs +++ b/crates/osprey-codegen/src/strings.rs @@ -145,8 +145,7 @@ pub(crate) fn gen_size(cg: &mut Codegen, name: &str, recv: Value) -> Result = ops.iter().map(String::as_str).collect(); let raw = cg.call("i64", cname, ¶ms, &op_refs); - let r = cg.fresh_reg(); - cg.emit(format!("{r} = icmp ne i64 {raw}, 0")); + let r = cg.emit_reg(format!("icmp ne i64 {raw}, 0")); Ok(Value::new(r, LType::I1)) } @@ -242,8 +240,7 @@ fn contains(cg: &mut Codegen, args: &[Expr], _named: &[NamedArgument]) -> Result let s = arg(cg, args, 0, LType::Str)?; let needle = arg(cg, args, 1, LType::Str)?; let hit = cg.call("i8*", "strstr", "i8*, i8*", &[&s.operand, &needle.operand]); - let r = cg.fresh_reg(); - cg.emit(format!("{r} = icmp ne i8* {hit}, null")); + let r = cg.emit_reg(format!("icmp ne i8* {hit}, null")); Ok(Value::new(r, LType::I1)) } @@ -257,10 +254,8 @@ fn index_of(cg: &mut Codegen, args: &[Expr], _named: &[NamedArgument]) -> Result "i8*, i8*", &[&s.operand, &needle.operand], ); - let iserr = cg.fresh_reg(); - cg.emit(format!("{iserr} = icmp slt i64 {idx}, 0")); - let val = cg.fresh_reg(); - cg.emit(format!("{val} = select i1 {iserr}, i64 0, i64 {idx}")); + let iserr = cg.emit_reg(format!("icmp slt i64 {idx}, 0")); + let val = cg.emit_reg(format!("select i1 {iserr}, i64 0, i64 {idx}")); make_result_if_err( cg, Value::new(val, LType::I64), @@ -315,8 +310,7 @@ fn parse_strict( _named: &[NamedArgument], ) -> Result { let s = arg(cg, args, 0, LType::Str)?; - let slot = cg.fresh_reg(); - cg.emit(format!("{slot} = alloca {inner}")); + let slot = cg.emit_reg(format!("alloca {inner}")); let zero = crate::llty::zero_literal(inner); cg.emit(format!("store {inner} {zero}, {inner}* {slot}")); let rc = cg.call( @@ -325,10 +319,8 @@ fn parse_strict( &format!("i8*, {inner}*"), &[&s.operand, &slot], ); - let parsed = cg.fresh_reg(); - cg.emit(format!("{parsed} = load {inner}, {inner}* {slot}")); - let iserr = cg.fresh_reg(); - cg.emit(format!("{iserr} = icmp ne i64 {rc}, 0")); + let parsed = cg.emit_reg(format!("load {inner}, {inner}* {slot}")); + let iserr = cg.emit_reg(format!("icmp ne i64 {rc}, 0")); make_result_if_err(cg, Value::new(parsed, inner), inner, &iserr, Some(errmsg)) } @@ -354,8 +346,7 @@ fn split(cg: &mut Codegen, args: &[Expr]) -> Result { &[&s.operand, &sep.operand], ); crate::arc::own(cg, &Value::new(&ptr, LType::Ptr)); - let iserr = cg.fresh_reg(); - cg.emit(format!("{iserr} = icmp eq i8* {ptr}, null")); + let iserr = cg.emit_reg(format!("icmp eq i8* {ptr}, null")); make_result_if_err( cg, Value::handle(ptr, crate::listlit::STRING_LIST_OWNER), @@ -371,19 +362,15 @@ fn split(cg: &mut Codegen, args: &[Expr]) -> Result { /// errmsg slot. `argtys` lists the leading argument types before the out-slot. fn cursor_int(cg: &mut Codegen, cname: &str, argtys: &[LType], args: &[Expr]) -> Result { let (mut ops, params) = typed_args_for_types(cg, argtys, args)?; - let slot = cg.fresh_reg(); - cg.emit(format!("{slot} = alloca i64")); + let slot = cg.emit_reg("alloca i64"); cg.emit(format!("store i64 0, i64* {slot}")); ops.push(slot.clone()); let full_params = format!("{params}, i64*"); let op_refs: Vec<&str> = ops.iter().map(String::as_str).collect(); let emsg = cg.call("i8*", cname, &full_params, &op_refs); - let parsed = cg.fresh_reg(); - cg.emit(format!("{parsed} = load i64, i64* {slot}")); - let is_err = cg.fresh_reg(); - cg.emit(format!("{is_err} = icmp ne i8* {emsg}, null")); - let disc = cg.fresh_reg(); - cg.emit(format!("{disc} = select i1 {is_err}, i8 1, i8 0")); + let parsed = cg.emit_reg(format!("load i64, i64* {slot}")); + let is_err = cg.emit_reg(format!("icmp ne i8* {emsg}, null")); + let disc = cg.emit_reg(format!("select i1 {is_err}, i8 1, i8 0")); make_result(cg, Value::new(parsed, LType::I64), LType::I64, &disc, &emsg) } diff --git a/crates/osprey-codegen/src/types.rs b/crates/osprey-codegen/src/types.rs index 0aee19b3..318ee071 100644 --- a/crates/osprey-codegen/src/types.rs +++ b/crates/osprey-codegen/src/types.rs @@ -24,7 +24,7 @@ pub(crate) fn elem_tag(prog: &ProgramTypes, elem: Option<&Type>) -> Option LType { +pub(crate) fn ltype_of(ty: &Type) -> LType { match ty { Type::Con { name, args } => ltype_of_con(name, args), // A function reference is a code pointer; values never hold one directly @@ -95,7 +95,7 @@ pub(crate) fn result_payload_owner(prog: &ProgramTypes, ty: &Type) -> Option` ([`crate::gpu::GPU_TAG`]), the same convention flat /// list literals use (`[]double`), so combinator lowering recovers the /// element's `LType` through parameters and returns [GPU-BUFFER-ELEM]. -pub fn owner_name(prog: &ProgramTypes, ty: &Type) -> Option { +pub(crate) fn owner_name(prog: &ProgramTypes, ty: &Type) -> Option { match ty { Type::Record { name, fields } if prog @@ -194,7 +194,7 @@ fn substituted(ty: &Type, args: &[Type]) -> Type { /// "every value of this type is a constructor-built ARC body or NULL" true. /// A `Result` is its own discriminated block and therefore does not prove /// that the outer value is a heap value of `T`. -pub fn proven_heap_name(ty: &Type) -> Option<&str> { +pub(crate) fn proven_heap_name(ty: &Type) -> Option<&str> { match ty { Type::Con { name, .. } if name == names::RESULT => None, // A declared union or any other named constructor: the name IS the proof. @@ -205,7 +205,7 @@ pub fn proven_heap_name(ty: &Type) -> Option<&str> { /// When `ty` is `Result`, the inner success type `T` as an [`LType`]. /// Used to carry the `{ T, i8 }*` Result block across call/return boundaries. -pub fn result_inner(ty: &Type) -> Option { +pub(crate) fn result_inner(ty: &Type) -> Option { match ty { Type::Con { name, args } if name == names::RESULT => args.first().map(ltype_of), _ => None, @@ -214,7 +214,7 @@ pub fn result_inner(ty: &Type) -> Option { /// Whether a function type yields a concrete closure ABI: every parameter and /// return are variable-free. Result returns keep their wrapper in the ABI. -pub fn fn_value_concrete(ty: &Type) -> bool { +pub(crate) fn fn_value_concrete(ty: &Type) -> bool { match ty { Type::Fun { params, ret } => { !params.iter().any(osprey_types::has_type_var) && !osprey_types::has_type_var(ret) diff --git a/crates/osprey-lsp/src/analysis.rs b/crates/osprey-lsp/src/analysis.rs index 5f7ff740..c9295025 100644 --- a/crates/osprey-lsp/src/analysis.rs +++ b/crates/osprey-lsp/src/analysis.rs @@ -5,10 +5,9 @@ //! into editor symbols — both the language server and the `osprey --symbols` / //! `osprey --hover` CLI modes render from here. -use osprey_ast::{ - walk_each, Expr, ExternParameter, InterpolatedPart, NamedArgument, Parameter, Position, - Program, Stmt, TypeExpr, -}; +#[cfg(test)] +use osprey_ast::InterpolatedPart; +use osprey_ast::{AstNode, Expr, ExternParameter, Parameter, Position, Program, Stmt, TypeExpr}; use std::fmt::Write as _; /// What kind of declaration a [`SymbolInfo`] describes. @@ -227,142 +226,22 @@ fn walk_stmt_body(stmt: &Stmt, prefix: &[String], out: &mut Vec) { } } -/// Descend an expression collecting nested `let` bindings (first third). +/// Descend expressions while preserving block-local symbol collection. fn walk_expr(e: &Expr, prefix: &[String], out: &mut Vec) { match e { - Expr::InterpolatedStr(parts) => parts.iter().for_each(|p| { - if let InterpolatedPart::Expr(x) = p { - walk_expr(x, prefix, out); - } - }), - Expr::List(xs, _) => walk_each(xs, out, |x| x, |x, out| walk_expr(x, prefix, out)), - Expr::Map(entries) => entries.iter().for_each(|en| { - walk_expr(&en.key, prefix, out); - walk_expr(&en.value, prefix, out); - }), - Expr::Object(fields) => walk_each( - fields, - out, - |f| &f.value, - |x, out| { - walk_expr(x, prefix, out); - }, - ), - Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - walk_expr(left, prefix, out); - walk_expr(right, prefix, out); - } - Expr::TypeApply { - function: operand, .. - } - | Expr::Unary { operand, .. } => walk_expr(operand, prefix, out), - other => walk_expr_rest(other, prefix, out), - } -} - -/// Continuation of [`walk_expr`] — call/navigation/block forms (second third). -fn walk_expr_rest(e: &Expr, prefix: &[String], out: &mut Vec) { - match e { - Expr::Call { - function, - arguments, - named_arguments, - } => { - walk_expr(function, prefix, out); - walk_arguments(arguments, named_arguments, prefix, out); - } - Expr::MethodCall { - target, - arguments, - named_arguments, - .. - } => { - walk_expr(target, prefix, out); - walk_arguments(arguments, named_arguments, prefix, out); - } - Expr::FieldAccess { target, .. } => walk_expr(target, prefix, out), - Expr::Index { target, index } => { - walk_expr(target, prefix, out); - walk_expr(index, prefix, out); - } - Expr::Lambda { body, .. } => walk_expr(body, prefix, out), - Expr::Match { value, arms } => { - walk_expr(value, prefix, out); - walk_each( - arms, - out, - |arm| &arm.body, - |x, out| { - walk_expr(x, prefix, out); - }, - ); - } Expr::Block { statements, value } => { walk_stmts(statements, prefix, Bodies::Descend, out); - if let Some(v) = value { - walk_expr(v, prefix, out); + if let Some(value) = value { + walk_expr(value, prefix, out); } } - Expr::TypeConstructor { fields, .. } | Expr::Update { fields, .. } => { - walk_each( - fields, - out, - |f| &f.value, - |x, out| { - walk_expr(x, prefix, out); - }, - ); - } - other => walk_expr_fiber(other, prefix, out), - } -} - -/// Final third of [`walk_expr`]: fiber/effect forms; leaves fall through. -fn walk_expr_fiber(e: &Expr, prefix: &[String], out: &mut Vec) { - match e { - Expr::Spawn(i) | Expr::Await(i) | Expr::Recv(i) | Expr::Yield(Some(i)) => { - walk_expr(i, prefix, out); - } - Expr::Send { channel, value } => { - walk_expr(channel, prefix, out); - walk_expr(value, prefix, out); - } - Expr::Select { arms } => walk_each( - arms, - out, - |arm| &arm.body, - |x, out| { - walk_expr(x, prefix, out); - }, - ), - Expr::Perform { - arguments, - named_arguments, - .. - } => { - walk_arguments(arguments, named_arguments, prefix, out); - } - Expr::Handler { arms, body, .. } => { - for arm in arms { - walk_expr(&arm.body, prefix, out); + // Resume operands were not part of this symbol collector's traversal. + Expr::Resume(_) => {} + _ => AstNode::Expression(e).for_each_child(|child| { + if let AstNode::Expression(expression) = child { + walk_expr(expression, prefix, out); } - walk_expr(body, prefix, out); - } - _ => {} - } -} - -fn walk_arguments( - arguments: &[Expr], - named_arguments: &[NamedArgument], - prefix: &[String], - out: &mut Vec, -) { - for argument in arguments { - walk_expr(argument, prefix, out); - } - for argument in named_arguments { - walk_expr(&argument.value, prefix, out); + }), } } @@ -755,6 +634,18 @@ pub(crate) fn json_str(s: &str) -> String { #[cfg(test)] mod tests { use super::*; + /// Assert the symbol named `name` carries a doc comment mentioning `needle` + /// — the find-then-unwrap chain these cases otherwise repeat per symbol. + fn assert_doc(syms: &[SymbolInfo], name: &str, needle: &str) { + let doc = syms + .iter() + .find(|s| s.name == name) + .and_then(|s| s.doc.clone()); + assert!( + doc.is_some_and(|d| d.contains(needle)), + "no doc mentioning {needle:?} on {name}" + ); + } #[test] fn outline_covers_every_declaration_form() { @@ -1008,22 +899,8 @@ print(describeAny(42) + "!") let parsed = osprey_syntax::parse_program_with_flavor(src, osprey_syntax::Flavor::Ml); assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); let syms = collect_all_symbols(&parsed.program); - let doc = syms - .iter() - .find(|s| s.name == "double") - .and_then(|s| s.doc.clone()); - assert!( - doc.is_some_and(|d| d.contains("Doubles the input.")), - "ml fn doc" - ); - let tdoc = syms - .iter() - .find(|s| s.name == "Tier") - .and_then(|s| s.doc.clone()); - assert!( - tdoc.is_some_and(|d| d.contains("A performance tier.")), - "ml type doc" - ); + assert_doc(&syms, "double", "Doubles the input."); + assert_doc(&syms, "Tier", "A performance tier."); } #[test] @@ -1132,7 +1009,7 @@ print(describeAny(42) + "!") clippy::too_many_lines, reason = "exhaustive fixture: one arm per AST container variant is the point" )] - fn every_container_with_a_nested_let() -> Vec { + fn every_container_with_a_nested_let() -> Vec { use osprey_ast::{ Expr, FieldAssignment, HandlerArm, MapEntry, MatchArm, NamedArgument, Pattern, }; diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs index d66c7e8d..2d3a6cea 100644 --- a/crates/osprey-lsp/src/diagnostics.rs +++ b/crates/osprey-lsp/src/diagnostics.rs @@ -354,6 +354,21 @@ fn byte_col_to_encoding(line: Option<&str>, byte_col: u32, encoding: PositionEnc .map_or(byte_col, |prefix| crate::text::measure(prefix, encoding)) } +#[cfg(test)] +pub(crate) fn assert_redundant_annotations( + actual: &[Diagnostic], + expected: &[(&str, crate::model::Span)], +) { + assert_eq!(actual.len(), expected.len(), "{actual:?}"); + for (diagnostic, (message, range)) in actual.iter().zip(expected) { + assert_eq!(diagnostic.severity, Severity::Warning, "{diagnostic:?}"); + assert_eq!(diagnostic.code.as_deref(), Some("redundant-annotation")); + assert_eq!(diagnostic.source.as_deref(), Some("osprey")); + assert_eq!(diagnostic.message, *message); + assert_eq!(diagnostic.range, *range, "{diagnostic:?}"); + } +} + #[cfg(test)] mod tests { use super::*; @@ -362,9 +377,16 @@ mod tests { const OSP: &str = "file:///a.osp"; #[test] - fn clean_program_has_no_diagnostics() { + fn inferred_program_is_clean_and_redundant_return_is_a_warning() { + assert!(compute("fn main() = print(\"hi\")\n", OSP, U16).is_empty()); let diags = compute("fn main() -> Unit = print(\"hi\")\n", OSP, U16); - assert!(diags.is_empty(), "{diags:?}"); + assert_redundant_annotations( + &diags, + &[( + "redundant return type annotation on `main`: inference derives `Unit` without it", + (0, 3, 0, 31), + )], + ); } #[test] @@ -374,10 +396,13 @@ mod tests { // cleanly under the ML frontend rather than be flagged as broken Default // syntax. Selecting the flavor by the document path is what fixes it. let ml = "inc : int -> int\ninc x = (x + 1) ?: 0\nmain () =\n print \"v=${toString (inc 41)}\"\n 0\n"; - let clean = compute(ml, "file:///tour.ospml", U16); - assert!( - clean.is_empty(), - "ML file should not syntax-error: {clean:?}" + let diagnostics = compute(ml, "file:///tour.ospml", U16); + assert_redundant_annotations( + &diagnostics, + &[( + "redundant type signature on `inc`: inference derives `(int) -> int` without it", + (0, 0, 0, 16), + )], ); // The same source under a `.osp` path is genuinely not Default syntax, so // the Default frontend still reports errors — proving the path drives the @@ -387,6 +412,13 @@ mod tests { !as_default.is_empty(), "ML source is not valid Default syntax" ); + assert!( + as_default.iter().all(|diagnostic| { + diagnostic.severity == Severity::Error + && diagnostic.code.as_deref() == Some("syntax-error") + }), + "{as_default:?}" + ); } #[test] @@ -566,15 +598,36 @@ mod tests { #[test] fn module_files_use_the_assembled_project_graph() { let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); - for relative in [ - "examples/projects/modules/src/main.ospml", - "examples/projects/modules/src/web/pages.ospml", + let main_warnings = [ + ( + "redundant type signature on `bank::fetch`: inference derives `(int) -> (string) -> string` without it", + (20, 0, 20, 31), + ), + ( + "redundant type signature on `bank::drive`: inference derives `(int) -> Unit` without it", + (32, 0, 32, 19), + ), + ( + "redundant return type annotation on `bank::hold`: inference derives `int` without it", + (55, 0, 55, 9), + ), + ( + "redundant type signature on `bank::handleRequest`: inference derives `(string, string, string, string) -> HttpResponse` without it", + (113, 0, 113, 68), + ), + ]; + for (relative, expected) in [ + ( + "examples/projects/modules/src/main.ospml", + main_warnings.as_slice(), + ), + ("examples/projects/modules/src/web/pages.ospml", &[]), ] { let path = root.join(relative); let source = std::fs::read_to_string(&path).expect("read module example"); let uri = format!("file://{}", path.display()); let diagnostics = compute(&source, &uri, U16); - assert!(diagnostics.is_empty(), "{relative}: {diagnostics:?}"); + assert_redundant_annotations(&diagnostics, expected); } } @@ -591,7 +644,55 @@ mod tests { let source = std::fs::read_to_string(&path).expect("read module test suite"); let uri = format!("file://{}", path.display()); let diagnostics = compute(&source, &uri, U16); - assert!(diagnostics.is_empty(), "{diagnostics:?}"); + assert_redundant_annotations( + &diagnostics, + &[ + ( + "redundant type signature on `test::Money::pennies`: inference derives `(int) -> string` without it", + (8, 4, 8, 27), + ), + ( + "redundant type signature on `test::Money::triple`: inference derives `(int) -> string` without it", + (15, 4, 15, 26), + ), + ( + "redundant type signature on `test::Money::group`: inference derives `(int) -> string` without it", + (22, 4, 22, 25), + ), + ( + "redundant type signature on `test::Money::show`: inference derives `(int) -> string` without it", + (30, 11, 30, 31), + ), + ( + "redundant type signature on `test::Money::positive`: inference derives `(int) -> bool` without it", + (33, 11, 33, 33), + ), + ( + "redundant type signature on `test::Json::escape`: inference derives `(string) -> string` without it", + (37, 4, 37, 29), + ), + ( + "redundant type signature on `test::Json::quoted`: inference derives `(string) -> string` without it", + (44, 4, 44, 29), + ), + ( + "redundant type signature on `test::Json::strField`: inference derives `(string) -> (string) -> string` without it", + (49, 11, 49, 48), + ), + ( + "redundant type signature on `test::Json::obj`: inference derives `(string) -> string` without it", + (55, 11, 55, 33), + ), + ( + "redundant type signature on `test::Accounts::movable`: inference derives `(int) -> bool` without it", + (73, 11, 73, 32), + ), + ( + "redundant type signature on `test::settle`: inference derives `(test::Outcome) -> string` without it", + (89, 0, 89, 26), + ), + ], + ); } #[cfg(unix)] diff --git a/crates/osprey-lsp/src/engine.rs b/crates/osprey-lsp/src/engine.rs index 2fb67404..833dc257 100644 --- a/crates/osprey-lsp/src/engine.rs +++ b/crates/osprey-lsp/src/engine.rs @@ -282,9 +282,25 @@ mod tests { } other => panic!("expected completion, got {other:?}"), } - // Diagnostics on a clean program are empty. + // [TYPE-ANNOTATION-REDUNDANT] Each written Default annotation warns. match report(Query::Diagnostics(uri.clone())).await { - Report::Diagnostics(diags) => assert!(diags.is_empty(), "{diags:?}"), + Report::Diagnostics(diags) => diagnostics::assert_redundant_annotations( + &diags, + &[ + ( + "redundant type annotation on parameter `a` of `add`: inference derives `int` without it", + (0, 3, 0, 44), + ), + ( + "redundant type annotation on parameter `b` of `add`: inference derives `int` without it", + (0, 3, 0, 44), + ), + ( + "redundant return type annotation on `add`: inference derives `int` without it", + (0, 3, 0, 44), + ), + ], + ), other => panic!("expected diagnostics, got {other:?}"), } // The vfs getter exposes the shared store. diff --git a/crates/osprey-lsp/src/features.rs b/crates/osprey-lsp/src/features.rs index d16e2e68..045031d6 100644 --- a/crates/osprey-lsp/src/features.rs +++ b/crates/osprey-lsp/src/features.rs @@ -391,6 +391,7 @@ fn step_call(c: char, names: &mut Vec, commas: &mut Vec, last: &mut mod tests { use super::*; use crate::hover::hover; + use crate::test_support::col_of; const U16: PositionEncoding = PositionEncoding::Utf16; const SRC: &str = "fn add(a: int, b: int) -> int = (a + b) ?: 0\nlet total = add(1, 2)\n"; @@ -474,14 +475,6 @@ mod tests { assert!(!references.iter().any(|location| location.span.0 == 4)); } - /// The 0-based column just inside the first occurrence of `needle` on - /// 0-based `line` of `src` — a cursor position over that word. - fn col_of(src: &str, line: usize, needle: &str) -> u32 { - let text = src.lines().nth(line).expect("line exists"); - let at = text.find(needle).expect("needle on line"); - u32::try_from(at).expect("column fits") + 1 - } - #[test] fn definition_and_references_return_empty_off_any_identifier() { // A two-space gap guarantees a column that is over neither word. diff --git a/crates/osprey-lsp/src/hover.rs b/crates/osprey-lsp/src/hover.rs index 7ceb4401..795b3456 100644 --- a/crates/osprey-lsp/src/hover.rs +++ b/crates/osprey-lsp/src/hover.rs @@ -254,6 +254,8 @@ fn inferred_parameter(program: &Program, function: &str, index: usize) -> Option #[cfg(test)] mod tests { use super::*; + use crate::test_support::col_of; + use crate::testkit::shows; const U16: PositionEncoding = PositionEncoding::Utf16; const SRC: &str = "fn add(a: int, b: int) -> int = (a + b) ?: 0\nlet total = add(1, 2)\n"; @@ -335,15 +337,13 @@ mod tests { // does not highlight. Re-apply the flavor at the presentation edge. let ml = "inc : int -> int\ninc x = (x + 1) ?: 0\n"; let hov = hover(ml, "file:///tour.ospml", 1, 0, U16).expect("hover"); - assert!(hov.contains("```osprey-ml"), "{hov}"); - assert!(hov.contains("inc : int -> int"), "{hov}"); + shows(&hov, &["```osprey-ml", "inc : int -> int"]); assert!(!hov.contains("fn inc("), "{hov}"); // The identical program under a `.osp` path keeps the Default spelling, // proving the flavor — not the content — drives the rendering. let default_src = "fn inc(x: int) -> int = (x + 1) ?: 0\n"; let plain = hover(default_src, "file:///a.osp", 0, 3, U16).expect("hover"); - assert!(plain.contains("```osprey\n"), "{plain}"); - assert!(plain.contains("fn inc(x: int) -> int"), "{plain}"); + shows(&plain, &["```osprey\n", "fn inc(x: int) -> int"]); } #[test] @@ -362,8 +362,7 @@ mod tests { // Implements [LSP-HOVER-VARIABLES], [LSP-HOVER-DOCS] let src = "fn main() -> int = {\n/// The greeting text.\nlet greeting = \"hi\"\n0\n}\n"; let md = hover(src, "file:///a.osp", 2, 6, U16).expect("hover over the `greeting` binding"); - assert!(md.contains("greeting: string"), "inferred type: {md}"); - assert!(md.contains("The greeting text."), "docs: {md}"); + shows(&md, &["greeting: string", "The greeting text."]); } #[test] @@ -372,8 +371,7 @@ mod tests { // Implements [LSP-HOVER-DOCS] let src = "/// Doubles `x`.\nfn dbl(x: int) -> int = (x * 2) ?: 0\n"; let md = hover(src, "file:///a.osp", 1, 4, U16).expect("hover over `dbl`"); - assert!(md.contains("fn dbl(x: int) -> int"), "signature: {md}"); - assert!(md.contains("Doubles `x`."), "docs: {md}"); + shows(&md, &["fn dbl(x: int) -> int", "Doubles `x`."]); let src = include_str!("../../../tests/effects/resume/resume_outer_handler_bridge.test.osp"); @@ -423,8 +421,10 @@ mod tests { let row = u32::try_from(line).expect("line fits"); let site = hover(src, "file:///trace.ospml", row, col, U16) .unwrap_or_else(|| panic!("hover over effect-operation site on line {line}")); - assert!(site.contains("Trace.mark : string => Unit"), "{site}"); - assert!(site.contains("Records trace markers."), "{site}"); + shows( + &site, + &["Trace.mark : string => Unit", "Records trace markers."], + ); } } @@ -582,8 +582,7 @@ mod tests { // Hovering the `int` in an annotation used to return nothing, because // no source file declares it. Implements [LSP-HOVER-WRITTEN]. let md = hover(SRC, "file:///a.osp", 0, 11, U16).expect("hover over `int`"); - assert!(md.contains("int"), "{md}"); - assert!(md.contains("64-bit integer"), "{md}"); + shows(&md, &["int", "64-bit integer"]); // A declared type still resolves to its declaration, not to this table. let declared = "type Shade = Light | Dark\nfn pick(s: Shade) = s\n"; let hovered = hover(declared, "file:///a.osp", 1, 12, U16).expect("hover over `Shade`"); @@ -630,11 +629,16 @@ test(\"identity\", fn() => expect(add(5, 0), 5)) "; let first = hover(src, "file:///suite.test.osp", 9, 1, U16).expect("hover over `test`"); assert!(first.starts_with("**Test:** commutes"), "{first}"); - assert!(first.contains("Addition is commutative."), "{first}"); - assert!(first.contains("**Parameters**"), "{first}"); - assert!(first.contains("- `left` — the first addend"), "{first}"); - assert!(first.contains("**Since**"), "{first}"); - assert!(first.contains("0.3"), "{first}"); + shows( + &first, + &[ + "Addition is commutative.", + "**Parameters**", + "- `left` — the first addend", + "**Since**", + "0.3", + ], + ); // The SECOND case's hover shows the second case's docs, not the first's. let second = hover(src, "file:///suite.test.osp", 12, 1, U16).expect("hover over `test`"); assert!(second.starts_with("**Test:** identity"), "{second}"); @@ -676,8 +680,7 @@ test(\"identity\", fn() => expect(add(5, 0), 5)) // user-declared `test` binding keeps hovering as itself. let src = "/// A local shadow.\nlet test = 1\nprint(\"${test}\")\n"; let md = hover(src, "file:///a.osp", 1, 5, U16).expect("hover over the binding"); - assert!(md.contains("test: int"), "{md}"); - assert!(md.contains("A local shadow."), "{md}"); + shows(&md, &["test: int", "A local shadow."]); assert!(!md.contains("**Test:**"), "not a test case: {md}"); } @@ -695,12 +698,4 @@ test(\"identity\", fn() => expect(add(5, 0), 5)) let line = u32::try_from(index).expect("line fits"); (line, u32::try_from(at).expect("column fits") + 1) } - - /// The 0-based column just inside the first occurrence of `needle` on - /// 0-based `line` of `src` — a cursor position over that word. - fn col_of(src: &str, line: usize, needle: &str) -> u32 { - let text = src.lines().nth(line).expect("line exists"); - let at = text.find(needle).expect("needle on line"); - u32::try_from(at).expect("column fits") + 1 - } } diff --git a/crates/osprey-lsp/src/inferred_views.rs b/crates/osprey-lsp/src/inferred_views.rs index 8737b0ae..65b56dfa 100644 --- a/crates/osprey-lsp/src/inferred_views.rs +++ b/crates/osprey-lsp/src/inferred_views.rs @@ -15,6 +15,7 @@ #[cfg(test)] mod tests { + use crate::test_support::symbols as symbols_of; use lspkit_vfs::PositionEncoding; const U16: PositionEncoding = PositionEncoding::Utf16; @@ -131,9 +132,7 @@ mod tests { // exercises both hazards at once: the artefact `t5` and the `Unit` // fallback that replaced it. let src = "fn classify(xs) = match xs {\n [] => 0\n [head, ...tail] => listLength(xs)\n}\nlet e = classify([1])\n"; - let parsed = osprey_syntax::parse_program(src); - assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); - let symbols = crate::analysis::symbols_json(&parsed.program); + let symbols = symbols_of(src); let decl = crate::hover::hover(src, "file:///c.osp", 0, 4, U16).expect("hover decl"); // `xs` USED in the body, four lines from where it is bound: the two // views of one parameter that disagreed (`List<_>` vs `List`). @@ -201,9 +200,7 @@ mod tests { // prints it asserts something the compiler rejects. Saying nothing is // the only honest answer once there is nothing to say. let src = "fn id(x) = x\nlet a = id(1)\n"; - let parsed = osprey_syntax::parse_program(src); - assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); - let symbols = crate::analysis::symbols_json(&parsed.program); + let symbols = symbols_of(src); assert!( symbols.contains("\"signature\":\"fn id(x)\""), "an unprovable return drops the arrow entirely: {symbols}" @@ -230,13 +227,11 @@ mod tests { // A hole must not carry a number, or two renderings of one type would // disagree and an edit elsewhere would churn the tooltip. let src = "fn pair(a, b) = [a, b]\nlet p = pair(1, 2)\n"; - let parsed = osprey_syntax::parse_program(src); - assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); - let symbols = crate::analysis::symbols_json(&parsed.program); + let symbols = symbols_of(src); assert!(!regex_like_type_var(&symbols), "{symbols}"); // Rendering the same program twice is byte-identical: nothing in the // spelling depends on inference-run state. - assert_eq!(symbols, crate::analysis::symbols_json(&parsed.program)); + assert_eq!(symbols, symbols_of(src)); } /// Whether `s` mentions an inference name (`t5`, `t42`): a `t` that starts diff --git a/crates/osprey-lsp/src/lib.rs b/crates/osprey-lsp/src/lib.rs index 47c7d77b..2afa8829 100644 --- a/crates/osprey-lsp/src/lib.rs +++ b/crates/osprey-lsp/src/lib.rs @@ -22,7 +22,12 @@ pub(crate) mod mlrender; pub mod model; pub(crate) mod reference_docs; pub mod server; +#[cfg(test)] +mod test_support; pub mod testing; +#[cfg(test)] +#[path = "../../testkit.rs"] +mod testkit; pub mod text; pub(crate) mod wire; pub mod workspace; diff --git a/crates/osprey-lsp/src/server.rs b/crates/osprey-lsp/src/server.rs index 6d63d31d..527e2c03 100644 --- a/crates/osprey-lsp/src/server.rs +++ b/crates/osprey-lsp/src/server.rs @@ -210,37 +210,28 @@ async fn publish(engine: &OspreyEngine, bus: &lspkit_server::DiagnosticsBus, doc /// Implements [LSP-CAPABILITIES]. fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher { let dispatcher = Dispatcher::new(); - register( + positional( &dispatcher, engine, "textDocument/hover", - |e, p, c| async move { - Some(result(hover_value( - answer(&e, Query::Hover(at(&p)?), c).await, - ))) - }, + Query::Hover, + hover_value, ); - register( + positional( &dispatcher, engine, "textDocument/definition", - |e, p, c| async move { - Some(result(locations_value( - answer(&e, Query::Definition(at(&p)?), c).await, - ))) - }, + Query::Definition, + locations_value, ); // Standard implementation-provider routing makes VS Code expose its native // context-menu action. [LSP-IMPLEMENTATIONS-EFFECT-HANDLERS] - register( + positional( &dispatcher, engine, "textDocument/implementation", - |e, p, c| async move { - Some(result(locations_value( - answer(&e, Query::Implementation(at(&p)?), c).await, - ))) - }, + Query::Implementation, + locations_value, ); register( &dispatcher, @@ -254,15 +245,12 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher { Some(result(locations_value(answer(&e, query, c).await))) }, ); - register( + positional( &dispatcher, engine, "textDocument/signatureHelp", - |e, p, c| async move { - Some(result(signature_value( - answer(&e, Query::SignatureHelp(at(&p)?), c).await, - ))) - }, + Query::SignatureHelp, + signature_value, ); register( &dispatcher, @@ -277,15 +265,12 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher { ))) }, ); - register( + positional( &dispatcher, engine, "textDocument/completion", - |e, p, c| async move { - Some(result(completion_value( - answer(&e, Query::Completion(at(&p)?), c).await, - ))) - }, + Query::Completion, + completion_value, ); register( &dispatcher, @@ -301,6 +286,21 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher { dispatcher } +/// Register a request whose whole handling is "read a position, ask the engine +/// one query, render the answer" — the shape every purely positional method +/// shares. The three things that differ are its arguments. +fn positional( + dispatcher: &Dispatcher, + engine: &OspreyEngine, + method: &str, + query: fn(At) -> Query, + render: fn(Option) -> Value, +) { + register(dispatcher, engine, method, move |e, p, c| async move { + Some(result(render(answer(&e, query(at(&p)?), c).await))) + }); +} + /// Register one handler. The closure receives a cloned engine, the params, and /// a cancellation token, and returns the JSON result. fn register(dispatcher: &Dispatcher, engine: &OspreyEngine, method: &str, handler: F) @@ -607,21 +607,38 @@ mod tests { } #[tokio::test] - async fn did_open_publishes_clean_diagnostics_then_errors_on_change() { + async fn did_open_publishes_warnings_then_errors_on_change() { // Document synchronization drives compiler diagnostics. // [LSP-LIFECYCLE], [LSP-DIAGNOSTICS] let mut h = Harness::start(); - let clean = h.open(SRC).await; + let opened = h.open(SRC).await; assert_eq!( - clean.method.as_deref(), + opened.method.as_deref(), Some("textDocument/publishDiagnostics") ); - let params = clean.params.expect("diagnostics params"); + let params = opened.params.expect("diagnostics params"); assert_at(¶ms, "/uri", URI); + let expected: Vec<_> = [ + "redundant type annotation on parameter `a` of `add`: inference derives `int` without it", + "redundant type annotation on parameter `b` of `add`: inference derives `int` without it", + "redundant return type annotation on `add`: inference derives `int` without it", + ] + .into_iter() + .map(|message| json!({ + "code": "redundant-annotation", + "message": message, + "range": { + "start": { "line": 0, "character": 3 }, + "end": { "line": 0, "character": 44 } + }, + "severity": 2, + "source": "osprey" + })) + .collect(); assert_eq!( params.pointer("/diagnostics").and_then(Value::as_array), - Some(&Vec::new()), - "clean program has no diagnostics" + Some(&expected), + "redundant annotations publish precise warnings" ); // The engine now has the open document text. assert_eq!( diff --git a/crates/osprey-lsp/src/test_support.rs b/crates/osprey-lsp/src/test_support.rs new file mode 100644 index 00000000..ca9e3041 --- /dev/null +++ b/crates/osprey-lsp/src/test_support.rs @@ -0,0 +1,30 @@ +//! Test-only helpers shared by the editor-feature unit tests. +//! +//! Every feature test opens the same way: parse a snippet, fail loudly on any +//! syntax error, then ask one editor question about a cursor position. Each +//! `mod tests` used to carry its own copy of that preamble, so the copies +//! drifted apart on their failure messages while asserting the same thing. + +use osprey_ast::Program; + +/// Parse `src`, asserting it is syntactically valid. A snippet the PARSER +/// rejects must never be scored as a passing editor view. +pub(crate) fn parsed(src: &str) -> Program { + let parsed = osprey_syntax::parse_program(src); + assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); + parsed.program +} + +/// The symbol view of a valid snippet — the rendering the inference-view tests +/// inspect. +pub(crate) fn symbols(src: &str) -> String { + crate::analysis::symbols_json(&parsed(src)) +} + +/// The 0-based column just inside the first occurrence of `needle` on 0-based +/// `line` of `src` — a cursor position over that word. +pub(crate) fn col_of(src: &str, line: usize, needle: &str) -> u32 { + let text = src.lines().nth(line).expect("line exists"); + let at = text.find(needle).expect("needle on line"); + u32::try_from(at).expect("column fits") + 1 +} diff --git a/crates/osprey-lsp/src/testing.rs b/crates/osprey-lsp/src/testing.rs index 46aacf36..460170de 100644 --- a/crates/osprey-lsp/src/testing.rs +++ b/crates/osprey-lsp/src/testing.rs @@ -338,6 +338,7 @@ pub(crate) fn test_case_hover(program: &Program, line: u32) -> Option { )] mod tests { use super::*; + use crate::testkit::shows; use osprey_syntax::{parse_program, parse_program_with_flavor, Flavor}; fn program(src: &str) -> Program { @@ -722,8 +723,7 @@ test(\"undocumented\", fn() => expect(add(1, 1), 2)) let program = program(DOCUMENTED); let hov = test_case_hover(&program, 22).expect("hover on the `test(` line"); assert!(hov.starts_with("**Test:** commutes"), "{hov}"); - assert!(hov.contains("Addition is commutative."), "{hov}"); - assert!(hov.contains("**Parameters**"), "full doc, not just summary"); + shows(&hov, &["Addition is commutative.", "**Parameters**"]); // A line with no test case declared on it has no test hover at all. assert_eq!(test_case_hover(&program, 1), None); assert_eq!(test_case_hover(&program, 999), None); diff --git a/crates/osprey-profiler/src/lib.rs b/crates/osprey-profiler/src/lib.rs index 9240fd43..f9c1282b 100644 --- a/crates/osprey-profiler/src/lib.rs +++ b/crates/osprey-profiler/src/lib.rs @@ -17,6 +17,9 @@ mod symbolize; #[cfg(test)] mod e2e; #[cfg(test)] +#[path = "../../testkit.rs"] +mod testkit; +#[cfg(test)] pub(crate) mod testutil; use std::fmt; diff --git a/crates/osprey-profiler/src/report.rs b/crates/osprey-profiler/src/report.rs index 929564cf..92db0c27 100644 --- a/crates/osprey-profiler/src/report.rs +++ b/crates/osprey-profiler/src/report.rs @@ -184,6 +184,7 @@ mod tests { use crate::model::build_model; use crate::raw::Profile; use crate::symbolize::SymFrame; + use crate::testkit::shows; use crate::testutil::{model_of, osp_frame, profile, sample, thread}; /// 200 on-CPU samples on main (no low-sample note): 100 leaf on parse @@ -278,8 +279,7 @@ mod tests { report.contains("\x1b[33m"), "warm row must be yellow: {report}" ); - assert!(report.contains("\x1b[2m"), "cold row must be dim: {report}"); - assert!(report.contains(RESET)); + shows(&report, &["\x1b[2m", RESET]); } #[test] @@ -300,17 +300,19 @@ mod tests { #[test] fn zero_oncpu_samples_report_full_uncertainty() { let report = render_report("fib.osp", "fib", &tiny_model(0), false); - assert!(report.contains("±100.0%"), "{report}"); - assert!(report.contains("0 samples @ 1000Hz · 1 fiber"), "{report}"); + shows(&report, &["±100.0%", "0 samples @ 1000Hz · 1 fiber"]); } #[test] fn footer_names_the_exports_and_viewers() { let report = render(false); - assert!(report.contains("profile: fib.speedscope.json · fib.cpuprofile · fib.folded")); - assert!(report.contains( - "view: https://speedscope.app (drag the file) or open fib.cpuprofile in VS Code" - )); + shows( + &report, + &[ + "profile: fib.speedscope.json · fib.cpuprofile · fib.folded", + "view: https://speedscope.app (drag the file) or open fib.cpuprofile in VS Code", + ], + ); } #[test] diff --git a/crates/osprey-profiler/src/symbolize/mod.rs b/crates/osprey-profiler/src/symbolize/mod.rs index 0aaf5dff..bb3eb05d 100644 --- a/crates/osprey-profiler/src/symbolize/mod.rs +++ b/crates/osprey-profiler/src/symbolize/mod.rs @@ -226,6 +226,20 @@ fn lookup_chain(profile: &Profile, cache: &ChainCache, index: usize, pc: u64) -> #[cfg(test)] mod tests { use super::*; + /// An image loaded at `base` (after `slide`) whose executable range spans + /// `text .. text + text_size`. Every case here varies only these five + /// fields, so the zeroed remainder is written once instead of per literal. + fn image(path: &str, base: u64, slide: u64, text: u64, text_size: u64) -> Image { + Image { + path: path.to_owned(), + base, + slide, + text, + text_size, + arch: String::new(), + } + } + use crate::raw::{Sample, Thread}; use std::cell::RefCell; @@ -281,24 +295,7 @@ mod tests { #[test] fn pcs_fall_back_to_greatest_base_when_no_image_reports_a_text_range() { - let images = vec![ - Image { - path: "/a".to_owned(), - base: 100, - slide: 0, - text: 0, - text_size: 0, - arch: String::new(), - }, - Image { - path: "/b".to_owned(), - base: 500, - slide: 0, - text: 0, - text_size: 0, - arch: String::new(), - }, - ]; + let images = vec![image("/a", 100, 0, 0, 0), image("/b", 500, 0, 0, 0)]; assert_eq!(image_index_for(&images, 499), Some(0)); assert_eq!(image_index_for(&images, 500), Some(1)); assert_eq!(image_index_for(&images, 99), None); @@ -316,22 +313,20 @@ mod tests { #[test] fn a_shared_cache_pc_is_owned_by_the_image_whose_text_contains_it() { let images = vec![ - Image { - path: "/usr/lib/system/libsystem_malloc.dylib".to_owned(), - base: 0x1_8000_0000, - slide: 0, - text: 0x1_8030_0000, - text_size: 0x2_0000, - arch: String::new(), - }, - Image { - path: "/usr/lib/system/libsystem_kernel.dylib".to_owned(), - base: 0x1_8010_0000, - slide: 0, - text: 0x1_8040_0000, - text_size: 0x2_0000, - arch: String::new(), - }, + image( + "/usr/lib/system/libsystem_malloc.dylib", + 0x1_8000_0000, + 0, + 0x1_8030_0000, + 0x2_0000, + ), + image( + "/usr/lib/system/libsystem_kernel.dylib", + 0x1_8010_0000, + 0, + 0x1_8040_0000, + 0x2_0000, + ), ]; // The observed leaf: inside libsystem_malloc's __TEXT, but BELOW the // kernel image's header, which is what the old rule keyed on. @@ -346,14 +341,7 @@ mod tests { /// the end is not. #[test] fn a_reported_text_range_is_half_open() { - let image = Image { - path: "/bin/app".to_owned(), - base: 0, - slide: 0, - text: 0x4000, - text_size: 0x1000, - arch: String::new(), - }; + let image = image("/bin/app", 0, 0, 0x4000, 0x1000); assert!(image.text_contains(0x4000)); assert!(image.text_contains(0x4FFF)); assert!(!image.text_contains(0x5000)); @@ -381,22 +369,8 @@ mod tests { rate_hz: 997, dropped: 0, images: vec![ - Image { - path: "/bin/app".to_owned(), - base: 1000, - slide: 100, - text: 0, - text_size: 0, - arch: String::new(), - }, - Image { - path: "/usr/lib/sys".to_owned(), - base: 9000, - slide: 0, - text: 0, - text_size: 0, - arch: String::new(), - }, + image("/bin/app", 1000, 100, 0, 0), + image("/usr/lib/sys", 9000, 0, 0, 0), ], threads: vec![Thread { fiber: 0, diff --git a/crates/osprey-project/src/imports.rs b/crates/osprey-project/src/imports.rs index f2d9ba04..14e7aec3 100644 --- a/crates/osprey-project/src/imports.rs +++ b/crates/osprey-project/src/imports.rs @@ -15,19 +15,19 @@ pub(crate) struct ImportScope { } impl ImportScope { - pub fn alias(&self, name: &str) -> Option<&SymbolKey> { + pub(crate) fn alias(&self, name: &str) -> Option<&SymbolKey> { self.aliases.get(name) } - pub fn member(&self, name: &str) -> Option<&SymbolKey> { + pub(crate) fn member(&self, name: &str) -> Option<&SymbolKey> { self.members.get(name) } - pub fn is_ambiguous(&self, name: &str) -> bool { + pub(crate) fn is_ambiguous(&self, name: &str) -> bool { self.ambiguous.contains(name) } - pub fn aliases_for(&self, target: &SymbolKey) -> Vec { + pub(crate) fn aliases_for(&self, target: &SymbolKey) -> Vec { self.aliases .iter() .filter(|(_, candidate)| *candidate == target) diff --git a/crates/osprey-project/src/model.rs b/crates/osprey-project/src/model.rs index 8f102957..d6c27b0b 100644 --- a/crates/osprey-project/src/model.rs +++ b/crates/osprey-project/src/model.rs @@ -13,26 +13,26 @@ pub(crate) struct SymbolKey { } impl SymbolKey { - pub fn new(namespace: impl Into, path: Vec) -> Self { + pub(crate) fn new(namespace: impl Into, path: Vec) -> Self { Self { namespace: namespace.into(), path, } } - pub fn child(&self, name: impl Into) -> Self { + pub(crate) fn child(&self, name: impl Into) -> Self { let mut path = self.path.clone(); path.push(name.into()); Self::new(self.namespace.clone(), path) } - pub fn parent_path(&self) -> &[String] { + pub(crate) fn parent_path(&self) -> &[String] { self.path .get(..self.path.len().saturating_sub(1)) .unwrap_or_default() } - pub fn source_name(&self) -> String { + pub(crate) fn source_name(&self) -> String { std::iter::once(self.namespace.as_str()) .chain(self.path.iter().map(String::as_str)) .filter(|segment| !segment.is_empty()) @@ -40,7 +40,7 @@ impl SymbolKey { .join("::") } - pub fn mangled(&self) -> String { + pub(crate) fn mangled(&self) -> String { osprey_ast::symbol::mangle( std::iter::once(self.namespace.as_str()).chain(self.path.iter().map(String::as_str)), ) @@ -70,7 +70,7 @@ pub(crate) struct DeclInfo { } impl DeclInfo { - pub fn visible_from(&self, same_namespace: bool, module: &[String]) -> bool { + pub(crate) fn visible_from(&self, same_namespace: bool, module: &[String]) -> bool { self.visibility == Visibility::Exported || (same_namespace && module.starts_with(&self.owner)) } diff --git a/crates/osprey-project/src/name_resolve.rs b/crates/osprey-project/src/name_resolve.rs index 9b7d5db8..389fc810 100644 --- a/crates/osprey-project/src/name_resolve.rs +++ b/crates/osprey-project/src/name_resolve.rs @@ -6,7 +6,7 @@ use crate::resolve::{Context, Resolver}; use osprey_ast::Position; impl Resolver<'_> { - pub fn resolve_bare( + pub(crate) fn resolve_bare( &mut self, name: &str, context: &Context, @@ -32,7 +32,7 @@ impl Resolver<'_> { scope.and_then(|scope| scope.member(name)).cloned() } - pub fn resolve_path( + pub(crate) fn resolve_path( &mut self, segments: &[String], context: &Context, @@ -72,7 +72,12 @@ impl Resolver<'_> { None } - pub fn rewrite_value_name(&mut self, name: &mut String, context: &Context, required: bool) { + pub(crate) fn rewrite_value_name( + &mut self, + name: &mut String, + context: &Context, + required: bool, + ) { let key = if name.contains("::") { let segments = name.split("::").map(str::to_string).collect::>(); self.resolve_path(&segments, context, None) diff --git a/crates/osprey-project/src/resolve.rs b/crates/osprey-project/src/resolve.rs index ec4cd3f5..90720b0c 100644 --- a/crates/osprey-project/src/resolve.rs +++ b/crates/osprey-project/src/resolve.rs @@ -356,7 +356,7 @@ impl Resolver<'_> { self.entry_locals = locals; } - pub fn link_name(&mut self, key: &SymbolKey, entry_main: bool) -> String { + pub(crate) fn link_name(&mut self, key: &SymbolKey, entry_main: bool) -> String { let name = if entry_main { "main".to_string() } else if self @@ -373,7 +373,12 @@ impl Resolver<'_> { name } - pub fn error(&mut self, source: usize, position: Option, message: impl Into) { + pub(crate) fn error( + &mut self, + source: usize, + position: Option, + message: impl Into, + ) { self.errors .push(source_error(self.sources, source, position, message)); } diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs index a957d651..ca109cdf 100644 --- a/crates/osprey-project/src/rewrite.rs +++ b/crates/osprey-project/src/rewrite.rs @@ -18,7 +18,7 @@ fn locals_with_type_parameters(type_params: &[TypeParam]) -> Locals { impl Resolver<'_> { /// Resolves a constant initializer and rejects active-path recursion. /// Implements the constant half of [MODULES-CYCLES]. - pub fn constant_value(&mut self, key: &SymbolKey) -> Option { + pub(crate) fn constant_value(&mut self, key: &SymbolKey) -> Option { if let Some(value) = self.constant_cache.get(key) { return Some(value.clone()); } @@ -72,7 +72,7 @@ impl Resolver<'_> { clippy::too_many_lines, reason = "declaration rewriting is an exhaustive canonical AST match" )] - pub fn rewrite_declaration( + pub(crate) fn rewrite_declaration( &mut self, statement: &mut Stmt, context: &Context, @@ -202,7 +202,7 @@ impl Resolver<'_> { } } - pub fn rewrite_local_statement( + pub(crate) fn rewrite_local_statement( &mut self, statement: &mut Stmt, context: &Context, @@ -243,7 +243,12 @@ impl Resolver<'_> { clippy::too_many_lines, reason = "expression rewriting is an exhaustive canonical AST walk" )] - pub fn rewrite_expr(&mut self, expression: &mut Expr, context: &Context, locals: &mut Locals) { + pub(crate) fn rewrite_expr( + &mut self, + expression: &mut Expr, + context: &Context, + locals: &mut Locals, + ) { if let Expr::Identifier(name) = expression { let name = name.clone(); let mut rewritten = Expr::Identifier(name.clone()); diff --git a/crates/osprey-project/src/type_rewrite.rs b/crates/osprey-project/src/type_rewrite.rs index a81b8aa7..2849e0e4 100644 --- a/crates/osprey-project/src/type_rewrite.rs +++ b/crates/osprey-project/src/type_rewrite.rs @@ -6,7 +6,12 @@ use osprey_ast::{EffectRef, TypeExpr}; use std::collections::BTreeMap; impl Resolver<'_> { - pub fn rewrite_type(&mut self, ty: &mut TypeExpr, context: &Context, locals: &mut Locals) { + pub(crate) fn rewrite_type( + &mut self, + ty: &mut TypeExpr, + context: &Context, + locals: &mut Locals, + ) { for parameter in &mut ty.generic_params { self.rewrite_type(parameter, context, locals); } @@ -47,7 +52,7 @@ impl Resolver<'_> { ty.name = self.link_name(&key, false); } - pub fn rewrite_effect_refs( + pub(crate) fn rewrite_effect_refs( &mut self, effects: &mut [EffectRef], context: &Context, @@ -83,7 +88,7 @@ impl Resolver<'_> { } } - pub fn rewrite_type_text( + pub(crate) fn rewrite_type_text( &mut self, text: &str, context: &Context, diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index d4353250..1c0e3f6c 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -616,18 +616,17 @@ mod tests { Expr::Call { arguments, .. } => assert_eq!(arguments.len(), 2), other => panic!("expected call, got {other:?}"), } - // UFCS field-access call `o.m(1)` -> Call(m, [o, 1]). - match let_value("let r = o.m(1)\n") { - Expr::Call { - function, - arguments, - .. - } => { - assert!(matches!(*function, Expr::Identifier(ref n) if n == "m")); - assert_eq!(arguments.len(), 2); + // [BUILTIN-STRING-UFCS] Preserve the receiver until type checking can + // select its callable field or the free-function fallback. + assert_eq!( + let_value("let r = o.m(1)\n"), + Expr::MethodCall { + target: Box::new(Expr::Identifier("o".into())), + method: "m".into(), + arguments: vec![Expr::Integer(1)], + named_arguments: vec![], } - other => panic!("expected call, got {other:?}"), - } + ); // Plain field access and indexing. assert!(matches!( let_value("let r = o.field\n"), diff --git a/crates/osprey-syntax/src/default/lower.rs b/crates/osprey-syntax/src/default/lower.rs index 6ae8f5f2..d0d804f3 100644 --- a/crates/osprey-syntax/src/default/lower.rs +++ b/crates/osprey-syntax/src/default/lower.rs @@ -26,7 +26,7 @@ fn strip_doc_line(line: &str) -> &str { /// Holds the source bytes so node text can be sliced during lowering. #[derive(Debug)] -pub struct Lowerer<'a> { +pub(crate) struct Lowerer<'a> { src: &'a [u8], } @@ -764,7 +764,7 @@ fn negate_literal(e: Expr) -> Expr { )] mod tests { use crate::parse_tree; - use crate::test_support::{one_stmt, stmts}; + use crate::test_support::{assert_doc_pair, assert_summary, one_stmt, stmt_doc, stmts}; use osprey_ast::{Expr, Pattern, Stmt}; use tree_sitter::Node; @@ -780,16 +780,6 @@ mod tests { // ---------- [TESTING-DOC] expression-statement documentation ---------- - /// The doc comment lowered onto a statement, or `None`. - fn stmt_doc(stmt: &Stmt) -> Option<&osprey_ast::DocComment> { - match stmt { - Stmt::Expr { doc, .. } | Stmt::Let { doc, .. } | Stmt::Function { doc, .. } => { - doc.as_ref() - } - _ => None, - } - } - #[test] fn a_doc_comment_lowers_onto_the_expression_statement_it_precedes() { // A `test(...)` case is an expression statement, not a declaration, so @@ -836,15 +826,9 @@ mod tests { fn each_documented_statement_owns_only_its_own_doc() { let all = stmts("/// First.\ntest(\"a\", 1)\ntest(\"b\", 2)\n/// Third.\ntest(\"c\", 3)\n"); assert_eq!(all.len(), 3); - assert_eq!( - stmt_doc(&all[0]).map(|d| d.summary.as_str()), - Some("First.") - ); - assert_eq!(stmt_doc(&all[1]).map(|d| d.summary.as_str()), None); - assert_eq!( - stmt_doc(&all[2]).map(|d| d.summary.as_str()), - Some("Third.") - ); + assert_summary(&all[0], Some("First.")); + assert_summary(&all[1], None); + assert_summary(&all[2], Some("Third.")); } #[test] @@ -852,13 +836,7 @@ mod tests { // Adding the expression-statement slot must not steal a following // declaration's doc comment. let all = stmts("/// Runs it.\nprint(\"hi\")\n/// Adds.\nfn add(a, b) = a + b\n"); - assert_eq!(all.len(), 2); - assert_eq!( - stmt_doc(&all[0]).map(|d| d.summary.as_str()), - Some("Runs it.") - ); - assert!(matches!(all[1], Stmt::Function { .. })); - assert_eq!(stmt_doc(&all[1]).map(|d| d.summary.as_str()), Some("Adds.")); + assert_doc_pair(&all, "Runs it.", "Adds."); } #[test] @@ -870,10 +848,7 @@ mod tests { let Expr::Block { statements, .. } = body else { panic!("expected a block body, got {body:?}"); }; - assert_eq!( - stmt_doc(&statements[0]).map(|d| d.summary.as_str()), - Some("Inner case.") - ); + assert_summary(&statements[0], Some("Inner case.")); } #[test] diff --git a/crates/osprey-syntax/src/lib.rs b/crates/osprey-syntax/src/lib.rs index e3297953..c9a59ff1 100644 --- a/crates/osprey-syntax/src/lib.rs +++ b/crates/osprey-syntax/src/lib.rs @@ -116,23 +116,15 @@ pub fn parse_program_with_flavor(source: &str, flavor: Flavor) -> Parsed { discharge_static_handlers(parsed) } -/// Every function's dependency set: the static-effect operations it requires, -/// transitively, minus what it answers itself. Implements -/// [STAGE-SIGNALS-DIRTY] (docs/specs/0035-StagedEffects.md). +/// Every function's dependency set — the static-effect operations it requires, +/// transitively, minus what it answers itself — paired with the syntax errors +/// found deriving them. Implements [STAGE-SIGNALS-DIRTY] +/// (docs/specs/0035-StagedEffects.md). /// /// Computed on the program **before** static discharge, because discharge is /// what makes those reads free and this is what makes them visible. Every /// other entry point returns a discharged program, in which the dependency set /// no longer exists to be read. -#[must_use] -pub fn dependency_sets( - source: &str, - flavor: Flavor, -) -> std::collections::BTreeMap> { - dependency_report(source, flavor).0 -} - -/// The same dependency sets, paired with the syntax errors found deriving them. /// /// Parsing is best-effort, so a source that did not parse still yields a tree — /// and the dependency sets read off it are silently short. "This view reads no @@ -317,7 +309,7 @@ fn frame() = kernel\n Tile size => 8\nin shade(2)\n"; fn counter(n) = (perform Signal.read()) ?: n\n"; let ml = "static effect Signal T\n read : Unit => T\n\ncounter n = perform Signal.read () ?: n\n"; for (flavor, source) in [(Flavor::Default, default), (Flavor::Ml, ml)] { - let deps = dependency_sets(source, flavor); + let deps = dependency_report(source, flavor).0; assert_eq!( deps.get("counter").cloned().unwrap_or_default(), vec!["Signal.read"], diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index e72e64d5..cd9bf0e1 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -496,7 +496,7 @@ impl ItemLower { fn lower_namespace_name(name: MlNamespaceName) -> NamespaceName { match name { MlNamespaceName::Ident(label) => NamespaceName::Identifier(label), - MlNamespaceName::Quoted(label) => NamespaceName::Quoted(crate::strings::unquote(&label)), + MlNamespaceName::Quoted(label) => NamespaceName::Quoted(unquote(&label)), } } @@ -1514,21 +1514,11 @@ fn parse_fragment(frag: &str) -> Expr { )] mod tests { use super::super::parse_ml; - use crate::test_support::{ml_one_stmt, ml_stmts}; + use crate::test_support::{assert_doc_pair, assert_summary, ml_one_stmt, ml_stmts, stmt_doc}; use osprey_ast::{Expr, InterpolatedPart, Pattern, Stmt, Variance}; // ---------- [TESTING-DOC] expression-statement documentation ---------- - /// The doc comment lowered onto a statement, or `None`. - fn stmt_doc(stmt: &Stmt) -> Option<&osprey_ast::DocComment> { - match stmt { - Stmt::Expr { doc, .. } | Stmt::Let { doc, .. } | Stmt::Function { doc, .. } => { - doc.as_ref() - } - _ => None, - } - } - #[test] fn an_ml_block_doc_lowers_onto_the_expression_statement_it_precedes() { // `test "name" case` is an application expression, so documenting a @@ -1536,10 +1526,7 @@ mod tests { // ([TESTING-DOC], [DOC-SIGIL-ML]). let s = ml_one_stmt("(** Documents the call. *)\nprintLine \"hi\"\n"); assert!(matches!(s, Stmt::Expr { .. }), "still an expr stmt: {s:?}"); - assert_eq!( - stmt_doc(&s).map(|d| d.summary.as_str()), - Some("Documents the call.") - ); + assert_summary(&s, Some("Documents the call.")); } #[test] @@ -1552,10 +1539,7 @@ mod tests { fn an_ml_doc_is_consumed_by_the_first_statement_and_not_the_next() { let all = ml_stmts("(** First. *)\nprintLine \"a\"\nprintLine \"b\"\n"); assert_eq!(all.len(), 2); - assert_eq!( - stmt_doc(&all[0]).map(|d| d.summary.as_str()), - Some("First.") - ); + assert_summary(&all[0], Some("First.")); assert_eq!( stmt_doc(&all[1]).map(|d| d.summary.as_str()), None, @@ -1566,13 +1550,7 @@ mod tests { #[test] fn an_ml_binding_after_a_documented_statement_keeps_its_own_doc() { let all = ml_stmts("(** Runs it. *)\nprintLine \"hi\"\n(** Adds. *)\nadd a b = a + b\n"); - assert_eq!(all.len(), 2); - assert_eq!( - stmt_doc(&all[0]).map(|d| d.summary.as_str()), - Some("Runs it.") - ); - assert!(matches!(all[1], Stmt::Function { .. })); - assert_eq!(stmt_doc(&all[1]).map(|d| d.summary.as_str()), Some("Adds.")); + assert_doc_pair(&all, "Runs it.", "Adds."); } #[test] diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index 7969eda4..58169397 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -99,6 +99,14 @@ pub(super) struct Parser<'t> { } impl Parser<'_> { + /// Consume the separator between elements of a comma-separated list, + /// answering whether another element follows. A trailing comma before + /// `close` ends the list rather than demanding an element after it, so + /// `[1, 2,]` reads as two elements. + fn more_in_list(&mut self, close: &TokKind) -> bool { + self.eat(&TokKind::Comma) && self.peek() != close + } + pub(super) fn peek(&self) -> &TokKind { self.toks.get(self.i).map_or(&TokKind::Eof, |t| &t.kind) } @@ -1004,12 +1012,9 @@ impl Parser<'_> { if !matches!(self.peek(), TokKind::RParen) { loop { out.push(self.one_param()); - if !self.eat(&TokKind::Comma) { + if !self.more_in_list(&TokKind::RParen) { break; } - if matches!(self.peek(), TokKind::RParen) { - break; // tolerate a trailing comma - } } } if !self.eat(&TokKind::RParen) { @@ -1264,12 +1269,9 @@ impl Parser<'_> { if !matches!(self.peek(), TokKind::RParen) { loop { args.push(self.expr(0)); - if !self.eat(&TokKind::Comma) { + if !self.more_in_list(&TokKind::RParen) { break; } - if matches!(self.peek(), TokKind::RParen) { - break; // tolerate a trailing comma - } } } if !self.eat(&TokKind::RParen) { @@ -1485,12 +1487,9 @@ impl Parser<'_> { if !matches!(self.peek(), TokKind::RBracket) { loop { entries.push(self.map_entry()); - if !self.eat(&TokKind::Comma) { + if !self.more_in_list(&TokKind::RBracket) { break; } - if matches!(self.peek(), TokKind::RBracket) { - break; // tolerate a trailing comma - } } } if !self.eat(&TokKind::RBracket) { @@ -1915,12 +1914,9 @@ impl Parser<'_> { break; // `...rest` is always the final element } elements.push(self.pattern()); - if !self.eat(&TokKind::Comma) { + if !self.more_in_list(&TokKind::RBracket) { break; } - if matches!(self.peek(), TokKind::RBracket) { - break; // tolerate a trailing comma - } } } if !self.eat(&TokKind::RBracket) { @@ -1999,12 +1995,9 @@ impl Parser<'_> { Some(field) => fields.push(field), None => self.recover(), } - if !self.eat(&TokKind::Comma) { + if !self.more_in_list(&TokKind::RParen) { break; } - if matches!(self.peek(), TokKind::RParen) { - break; // tolerate a trailing comma - } } } if !self.eat(&TokKind::RParen) { diff --git a/crates/osprey-syntax/src/test_support.rs b/crates/osprey-syntax/src/test_support.rs index 67b0d842..c762bf87 100644 --- a/crates/osprey-syntax/src/test_support.rs +++ b/crates/osprey-syntax/src/test_support.rs @@ -53,3 +53,33 @@ fn only(mut statements: Vec) -> Stmt { // repository-forbidden `unwrap()`. statements.remove(0) } + +/// The doc comment lowered onto a statement, or `None`. Both flavors' tests +/// ask this same question of the same `Stmt`, so it is answered once. +pub(crate) fn stmt_doc(stmt: &Stmt) -> Option<&osprey_ast::DocComment> { + match stmt { + Stmt::Expr { doc, .. } | Stmt::Let { doc, .. } | Stmt::Function { doc, .. } => doc.as_ref(), + _ => None, + } +} + +/// Assert the doc summary lowered onto `stmt` — `None` demanding that no doc +/// was invented for it. Every doc-lowering case asks exactly this. +pub(crate) fn assert_summary(stmt: &Stmt, expected: Option<&str>) { + assert_eq!(stmt_doc(stmt).map(|d| d.summary.as_str()), expected); +} + +/// Assert a documented expression statement is followed by a documented +/// declaration that kept its OWN doc — the shape both flavors pin, differing +/// only in how each spells the source. +pub(crate) fn assert_doc_pair(all: &[Stmt], first: &str, second: &str) { + let [statement, declaration] = all else { + panic!( + "expected exactly two statements, got {}: {all:?}", + all.len() + ); + }; + assert_summary(statement, Some(first)); + assert!(matches!(declaration, Stmt::Function { .. })); + assert_summary(declaration, Some(second)); +} diff --git a/crates/osprey-syntax/tests/ml_elegance.rs b/crates/osprey-syntax/tests/ml_elegance.rs index c4eaf4a4..a270471c 100644 --- a/crates/osprey-syntax/tests/ml_elegance.rs +++ b/crates/osprey-syntax/tests/ml_elegance.rs @@ -428,9 +428,9 @@ fn structural_patterns_parse_closed_and_open() { /// The first match expression's arms anywhere in the program — the shared /// digging for the pattern-shape assertions above. fn find_match_arms(program: &osprey_ast::Program) -> Vec { - fn from_expr(e: &osprey_ast::Expr) -> Option> { + fn from_expr(e: &Expr) -> Option> { match e { - osprey_ast::Expr::Match { arms, .. } => Some(arms.clone()), + Expr::Match { arms, .. } => Some(arms.clone()), _ => None, } } diff --git a/crates/osprey-types/src/applications.rs b/crates/osprey-types/src/applications.rs index ddc80d20..1845dd8f 100644 --- a/crates/osprey-types/src/applications.rs +++ b/crates/osprey-types/src/applications.rs @@ -141,35 +141,22 @@ fn elaborate_expr(expression: &mut Expr, index: &mut usize, types: &mut ProgramT let Ok(column) = u32::try_from(current) else { return; }; - if matches!(expression, Expr::Identifier(_) | Expr::Path(_)) { - let _ = types.applications.insert((0, column), bindings); - *expression = Expr::TypeApply { - function: Box::new(expression.clone()), - type_args: Vec::new(), - position: Some(Position { line: 0, column }), - }; - return; - } - if matches!( - types.methods.get(¤t), - Some(crate::methods::Target::Deferred(_)) - ) { - let _ = types.applications.insert((0, column), bindings); - *expression = Expr::TypeApply { - function: Box::new(expression.clone()), - type_args: Vec::new(), - position: Some(Position { line: 0, column }), - }; - return; - } - let function = match expression { - Expr::Call { function, .. } => function, - Expr::Pipe { right, .. } => right, - _ => return, + let function = if matches!(expression, Expr::Identifier(_) | Expr::Path(_)) + || matches!( + types.methods.get(¤t), + Some(crate::methods::Target::Deferred(_)) + ) { + expression + } else { + match expression { + Expr::Call { function, .. } => function.as_mut(), + Expr::Pipe { right, .. } => right.as_mut(), + _ => return, + } }; let _ = types.applications.insert((0, column), bindings); - **function = Expr::TypeApply { - function: function.clone(), + *function = Expr::TypeApply { + function: Box::new(function.clone()), type_args: Vec::new(), position: Some(Position { line: 0, column }), }; diff --git a/crates/osprey-types/src/builtin_docs.rs b/crates/osprey-types/src/builtin_docs.rs index f227a4f0..7ea637a6 100644 --- a/crates/osprey-types/src/builtin_docs.rs +++ b/crates/osprey-types/src/builtin_docs.rs @@ -172,6 +172,7 @@ fn append_example(out: &mut String, example: &str) { #[cfg(test)] mod tests { use super::*; + use crate::testkit::shows; use std::collections::BTreeSet; #[test] @@ -204,11 +205,16 @@ mod tests { // `sleep`'s doc historically claimed `-> int`; the scheme says `-> Unit`, // and the rendered hover must follow the scheme, not the stale prose. let md = builtin_hover_markdown("sleep").expect("sleep is documented"); - assert!(md.contains("sleep(milliseconds: int) -> Unit"), "{md}"); - assert!(md.contains("Pauses execution"), "{md}"); - assert!(md.contains("**Parameters**"), "{md}"); - assert!(md.contains("**Returns** `Unit`"), "{md}"); - assert!(md.contains("**Example**"), "{md}"); + shows( + &md, + &[ + "sleep(milliseconds: int) -> Unit", + "Pauses execution", + "**Parameters**", + "**Returns** `Unit`", + "**Example**", + ], + ); assert!(builtin_hover_markdown("notARealBuiltin").is_none()); } diff --git a/crates/osprey-types/src/builtins.rs b/crates/osprey-types/src/builtins.rs index 78638006..c86a00ba 100644 --- a/crates/osprey-types/src/builtins.rs +++ b/crates/osprey-types/src/builtins.rs @@ -46,7 +46,7 @@ fn res(ok: Type) -> Type { /// free-in-env and silently blocking let-generalization — e.g. /// `fn identity(x) -> T = x` losing its polymorphism depending on which /// direction a var-var unification happened to bind. [TYPE-GENERICS-FN] -pub const RESERVED_SCHEME_VARS: u32 = 3; +pub(crate) const RESERVED_SCHEME_VARS: u32 = 3; fn mono(env: &mut TypeEnv, name: &str, params: Vec, ret: Type) { env.insert(name, Scheme::mono(Type::fun(params, ret))); @@ -59,7 +59,7 @@ fn poly(env: &mut TypeEnv, name: &str, vars: Vec, params: Vec, ret: T /// Built-ins a user function may redefine: the testing names are common /// identifiers, so a same-named user function shadows the built-in instead of /// erroring. Implements [TESTING-SHADOWING] (docs/specs/0027-TestingFramework.md). -pub const SHADOWABLE_BUILTINS: &[&str] = &[ +pub(crate) const SHADOWABLE_BUILTINS: &[&str] = &[ "test", "expect", "expectAll", @@ -72,7 +72,7 @@ pub const SHADOWABLE_BUILTINS: &[&str] = &[ ]; /// Install every built-in into a base environment. -pub fn base_env() -> TypeEnv { +pub(crate) fn base_env() -> TypeEnv { let mut e = TypeEnv::new(); core(&mut e); testing(&mut e); diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index e46428a1..0c605075 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -113,7 +113,7 @@ pub(crate) fn annotation_name(name: &str) -> String { } /// All cross-cutting declaration tables, plus the inference context. -pub struct Checker { +pub(crate) struct Checker { pub(crate) ctx: InferCtx, pub(crate) errors: Vec, pub(crate) ctors: HashMap, @@ -1623,7 +1623,7 @@ mod tests { use super::infer_program; use crate::check::check_program; use crate::error::TypeError; - use crate::testutil::{check, ok}; + use crate::testutil::{bad_with, check, ok}; use osprey_ast::{Expr, Stmt}; use osprey_syntax::parse_program; @@ -1704,28 +1704,26 @@ mod tests { assert!(errs.iter().any(|e| e.message.contains("type mismatch"))); // Module functions must run both declaration collection and body // checking; historically only module lets reached inference. - let errs = check( + bad_with( "module BadFn {\n\ fn broken() -> int = \"not an int\"\n\ }\n", + "type mismatch", ); - assert!(errs.iter().any(|e| e.message.contains("type mismatch"))); } #[test] fn a_discarded_result_statement_is_rejected() { // A bare statement whose value is a `Result` throws the failure away — // the one place the wrapper can vanish without anyone naming it. - let errs = check( + bad_with( "fn risky(n: int) -> Result = n + 1\n\ fn go() -> int = {\n\ risky(1)\n\ 0\n\ }\n", + "cannot be discarded", ); - assert!(errs - .iter() - .any(|e| e.message.contains("cannot be discarded"))); ok("fn risky(n: int) -> Result = n + 1\n\ fn go() -> int = {\n\ let handled = risky(1) ?: 0\n\ @@ -2040,10 +2038,7 @@ mod tests { let r = check(expect(test(1)))\n", ); assert!(errs.is_empty(), "unexpected type errors: {errs:?}"); - let errs = check("fn range(t: int) -> int = t\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("cannot redefine built-in"))); + bad_with("fn range(t: int) -> int = t\n", "cannot redefine built-in"); } #[test] diff --git a/crates/osprey-types/src/convert.rs b/crates/osprey-types/src/convert.rs index f641b621..065fe56c 100644 --- a/crates/osprey-types/src/convert.rs +++ b/crates/osprey-types/src/convert.rs @@ -11,7 +11,7 @@ use std::collections::HashMap; /// Convert a parsed `TypeExpr` into an inference type. `params` maps generic /// parameter names already bound to fresh variables for the enclosing decl. -pub fn type_expr_to_type(te: &TypeExpr, params: &HashMap) -> Type { +pub(crate) fn type_expr_to_type(te: &TypeExpr, params: &HashMap) -> Type { if te.is_function { let ps = te .parameter_types @@ -50,7 +50,7 @@ pub fn type_expr_to_type(te: &TypeExpr, params: &HashMap) -> Type /// `"Result"`, `"(int) -> bool"`) into a type. The shallow /// `Name<...>`, `[elem]` and function-arrow forms are recognised; that covers /// every field type used by the examples. -pub fn type_name_to_type(s: &str, params: &HashMap) -> Type { +pub(crate) fn type_name_to_type(s: &str, params: &HashMap) -> Type { let s = s.trim(); if let Some(var) = params.get(s) { return var.clone(); @@ -94,7 +94,7 @@ fn normalize_named(name: &str) -> Type { /// Parse an effect-operation / lambda type string `fn(p0, p1) -> ret` into /// inference types. Tolerant: a malformed string yields `() -> Unit`. -pub fn parse_fn_sig(s: &str, params: &HashMap) -> (Vec, Type) { +pub(crate) fn parse_fn_sig(s: &str, params: &HashMap) -> (Vec, Type) { let s = s.trim(); let s = s.strip_prefix("fn").map_or(s, str::trim_start).trim(); let Some(open) = s.find('(') else { @@ -145,6 +145,8 @@ fn split_generic_args(s: &str) -> Vec { for (i, ch) in s.char_indices() { match ch { '<' | '(' | '[' => depth += 1, + // The `>` in a function arrow does not close a generic argument. + '>' if s[..i].ends_with('-') => {} '>' | ')' | ']' => depth -= 1, ',' if depth == 0 => { out.push(s[start..i].trim().to_string()); diff --git a/crates/osprey-types/src/ctx.rs b/crates/osprey-types/src/ctx.rs index 47493461..f59a0c29 100644 --- a/crates/osprey-types/src/ctx.rs +++ b/crates/osprey-types/src/ctx.rs @@ -11,7 +11,7 @@ type RecordTemplate = (Vec, Vec<(String, String)>); /// Holds every type variable's binding. Variable ids are indices into `subst`. #[derive(Debug, Default)] -pub struct InferCtx { +pub(crate) struct InferCtx { subst: Vec>, /// Type-constructor name → declared per-parameter variance, consulted by /// assignability so `Source` matches covariantly. Implements @@ -23,18 +23,18 @@ pub struct InferCtx { impl InferCtx { /// Create an empty context with no allocated type variables. - pub fn new() -> InferCtx { + pub(crate) fn new() -> InferCtx { InferCtx::default() } /// Register a type constructor's declared per-parameter variance. - pub fn set_variance(&mut self, name: impl Into, variances: Vec) { + pub(crate) fn set_variance(&mut self, name: impl Into, variances: Vec) { let _ = self.variances.insert(name.into(), variances); } /// The declared per-parameter variance of a type constructor, if any. #[must_use] - pub fn variance_of(&self, name: &str) -> Option<&[Variance]> { + pub(crate) fn variance_of(&self, name: &str) -> Option<&[Variance]> { self.variances.get(name).map(Vec::as_slice) } @@ -73,7 +73,7 @@ impl InferCtx { } /// Allocate a fresh, unbound type variable. - pub fn fresh(&mut self) -> Type { + pub(crate) fn fresh(&mut self) -> Type { let id = VarId::try_from(self.subst.len()).unwrap_or(VarId::MAX); self.subst.push(None); Type::Var(id) @@ -82,7 +82,7 @@ impl InferCtx { /// Follow a variable to its representative, compressing the path. Only the /// outermost variable is resolved — nested types are left intact (use /// [`InferCtx::apply`] for a deep walk). - pub fn prune(&mut self, t: &Type) -> Type { + pub(crate) fn prune(&mut self, t: &Type) -> Type { if let Type::Var(id) = t { let idx = usize::try_from(*id).unwrap_or(usize::MAX); if let Some(bound) = self.subst.get(idx).and_then(Option::clone) { @@ -101,12 +101,12 @@ impl InferCtx { /// to learn" without diffing the whole substitution /// ([`crate::check::Checker::resolve_deferred_arithmetic`]). #[must_use] - pub fn bound_count(&self) -> usize { + pub(crate) fn bound_count(&self) -> usize { self.subst.iter().filter(|slot| slot.is_some()).count() } /// Bind a variable to a type. The caller guarantees the occurs-check passed. - pub fn bind(&mut self, id: VarId, t: Type) { + pub(crate) fn bind(&mut self, id: VarId, t: Type) { let idx = usize::try_from(id).unwrap_or(usize::MAX); if let Some(slot) = self.subst.get_mut(idx) { *slot = Some(t); @@ -115,7 +115,7 @@ impl InferCtx { /// The occurs check: does variable `id` appear anywhere in `t`? Prevents /// the construction of infinite types like `t0 ~ List`. - pub fn occurs(&mut self, id: VarId, t: &Type) -> bool { + pub(crate) fn occurs(&mut self, id: VarId, t: &Type) -> bool { let t = self.prune(t); match &t { Type::Var(v) => *v == id, @@ -130,7 +130,7 @@ impl InferCtx { /// Fully resolve `t` against the current substitution. The occurs-check /// keeps the substitution acyclic, so this terminates. - pub fn apply(&mut self, t: &Type) -> Type { + pub(crate) fn apply(&mut self, t: &Type) -> Type { let t = self.prune(t); match &t { Type::Var(_) => t, @@ -157,7 +157,7 @@ impl InferCtx { } /// Collect the free (unbound) variables of `t` into `out`. - pub fn free_vars(&mut self, t: &Type, out: &mut BTreeSet) { + pub(crate) fn free_vars(&mut self, t: &Type, out: &mut BTreeSet) { let t = self.prune(t); match &t { Type::Var(v) => { diff --git a/crates/osprey-types/src/effect_rows.rs b/crates/osprey-types/src/effect_rows.rs index 37cd1764..cc2f79fd 100644 --- a/crates/osprey-types/src/effect_rows.rs +++ b/crates/osprey-types/src/effect_rows.rs @@ -98,6 +98,16 @@ struct CallArguments { named: Vec<(String, Option)>, } +impl CallArguments { + /// Function-value slots have no parameter names. Do this at the call site, + /// before substitution reveals a callback's declaration and its names. + fn in_written_order(mut self) -> Self { + self.positional + .extend(self.named.drain(..).map(|(_, value)| value)); + self + } +} + #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] struct Summary { required: Requirements, @@ -576,9 +586,6 @@ impl Analyzer<'_> { reason = "the exhaustive AST effect fold is clearest as one variant-complete match" )] fn expression(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Summary { - if let Some(parts) = crate::methods::parts(expression) { - return self.method_call(expression, &parts, scope, env); - } match expression { Expr::Integer(_) | Expr::Float(_) @@ -610,11 +617,7 @@ impl Analyzer<'_> { Expr::Object(fields) | Expr::TypeConstructor { fields, .. } | Expr::Update { fields, .. } => { - let mut out = Summary::default(); - for field in fields { - out.union(self.expression(&field.value, scope, env)); - } - out + self.union_over(fields.iter().map(|field| &field.value), scope, env) } Expr::Binary { left, right, .. } => { let mut out = self.expression(left, scope, env); @@ -645,16 +648,24 @@ impl Analyzer<'_> { function, arguments, named_arguments, - } => self.call(function, arguments, named_arguments, scope, env), + } => match crate::methods::parts(expression) { + Some(parts) => self.method_call(expression, &parts, scope, env), + None => self.call(function, arguments, named_arguments, scope, env), + }, Expr::MethodCall { target, method, arguments, named_arguments, - } => self.call( - &Expr::Identifier(method.clone()), - &receiver_first(target, arguments), - named_arguments, + } => self.method_call( + expression, + &crate::methods::Parts { + target, + method, + arguments, + named: named_arguments, + application: None, + }, scope, env, ), @@ -669,11 +680,7 @@ impl Analyzer<'_> { out } Expr::Select { arms } => { - let mut out = Summary::default(); - for arm in arms { - out.union(self.expression(&arm.body, scope, env)); - } - out + self.union_over(arms.iter().map(|arm| &arm.body), scope, env) } Expr::Block { statements, value } => { let mut local = env.clone(); @@ -768,7 +775,9 @@ impl Analyzer<'_> { ) -> Summary { let mut out = Summary::default(); if let Some(callee) = self.callable(function, scope, env) { - out.union(self.invoke(callee, arguments, named_arguments, scope, env)); + let arguments = + self.callsite_arguments(function, arguments, named_arguments, scope, env); + out.union(self.invoke_with_arguments(callee, arguments)); } else if !statically_named_callee(function, env, self.index) { // A computed value that successfully type-checks as a function must // carry effect provenance. If an unsupported transport erased that @@ -787,7 +796,7 @@ impl Analyzer<'_> { for index in eager_callback_slots(name) { if let Some(argument) = arguments.get(*index) { if let Some(callback) = self.callable(argument, scope, env) { - out.union(self.invoke(callback, &[], &[], scope, env)); + out.union(self.invoke_with_values(callback, &[])); } } } @@ -813,7 +822,10 @@ impl Analyzer<'_> { .and_then(|value| project_field(value, field)) .and_then(|value| value.callable); if let Some(callee) = callee { - out.union(self.invoke(callee, parts.arguments, parts.named, scope, env)); + let arguments = self + .call_arguments(parts.arguments, parts.named, scope, env) + .in_written_order(); + out.union(self.invoke_with_arguments(callee, arguments)); } else { out.unresolved_dynamic_call = true; } @@ -886,14 +898,16 @@ impl Analyzer<'_> { fn project_method(&self, mut receiver: Value, method: MethodProjection) -> Option { let mut projected = if let Some(value) = receiver.fields.remove(&method.field) { value.callable.map(|callee| { - let parameters = match &callee { - Callable::Known(known) => known.parameters.as_slice(), - _ => &[], - }; - let arguments = ordered_values(parameters, &method.arguments, &method.named); + let arguments = CallArguments { + positional: method.arguments.clone(), + named: method.named.clone(), + } + .in_written_order(); + // A field can hold a caller's symbolic callback. Retain its + // returned-value projection until that callback is supplied. method_thunk( - self.invoke_with_values(callee.clone(), &arguments), - self.called_value_with_values(callee, &arguments), + self.invoke_with_arguments(callee.clone(), arguments.clone()), + self.project_call_return(Value::from_callable(callee), arguments), ) }) } else if receiver @@ -915,6 +929,41 @@ impl Analyzer<'_> { projected } + fn method_value( + &self, + expression: &Expr, + parts: &crate::methods::Parts<'_>, + scope: &[String], + env: &CallableEnv, + ) -> Option { + match self + .instances + .methods + .get(&std::ptr::from_ref(expression).addr()) + { + Some(crate::methods::Target::Field(field)) => { + let callee = self + .value(parts.target, scope, env) + .and_then(|value| project_field(value, field)) + .and_then(|value| value.callable); + let arguments = self + .call_arguments(parts.arguments, parts.named, scope, env) + .in_written_order(); + self.called_value(callee, arguments) + } + Some(crate::methods::Target::Deferred(field)) => self + .deferred_method(parts, field, scope, env) + .and_then(|value| self.project_returned(value)), + Some(crate::methods::Target::Function) | None => self.call_value( + &Expr::Identifier(parts.method.to_owned()), + &receiver_first(parts.target, parts.arguments), + parts.named, + scope, + env, + ), + } + } + fn project_path(&self, mut value: Value, path: &[Projection]) -> Option { for projection in path { value = match projection { @@ -953,18 +1002,6 @@ impl Analyzer<'_> { projected } - fn invoke( - &self, - callee: Callable, - arguments: &[Expr], - named_arguments: &[NamedArgument], - scope: &[String], - env: &CallableEnv, - ) -> Summary { - let arguments = self.call_arguments(arguments, named_arguments, scope, env); - self.invoke_with_arguments(callee, arguments) - } - fn invoke_with_values(&self, callee: Callable, arguments: &[Option]) -> Summary { self.invoke_with_arguments( callee, @@ -1006,30 +1043,6 @@ impl Analyzer<'_> { } } - fn argument_values( - &self, - parameters: &[String], - arguments: &[Expr], - named_arguments: &[NamedArgument], - scope: &[String], - env: &CallableEnv, - ) -> Vec> { - let mut values = vec![None; parameters.len().max(arguments.len())]; - for (index, argument) in arguments.iter().enumerate() { - if let Some(slot) = values.get_mut(index) { - *slot = self.value(argument, scope, env); - } - } - for argument in named_arguments { - if let Some(index) = parameters.iter().position(|name| name == &argument.name) { - if let Some(slot) = values.get_mut(index) { - *slot = self.value(&argument.value, scope, env); - } - } - } - values - } - fn call_value( &self, function: &Expr, @@ -1046,7 +1059,8 @@ impl Analyzer<'_> { // Preserve each application in a curried spine: its result can be a // returned closure or aggregate with different effects from its maker. let resolved = self.callable(function, scope, env); - self.called_value(resolved, arguments, named_arguments, scope, env) + let arguments = self.callsite_arguments(function, arguments, named_arguments, scope, env); + self.called_value(resolved, arguments) } /// Builtin behavior belongs to the resolved binding, not its spelling. @@ -1064,19 +1078,8 @@ impl Analyzer<'_> { .then_some(name) } - fn called_value( - &self, - resolved: Option, - arguments: &[Expr], - named_arguments: &[NamedArgument], - scope: &[String], - env: &CallableEnv, - ) -> Option { - if let Some(parameter @ Callable::Parameter { .. }) = resolved { - let arguments = self.call_arguments(arguments, named_arguments, scope, env); - return self.project_call_return(Value::from_callable(parameter), arguments); - } - let Some(Callable::Known(known)) = resolved else { + fn called_value(&self, resolved: Option, arguments: CallArguments) -> Option { + let Some(callee @ (Callable::Known(_) | Callable::Parameter { .. })) = resolved else { // The RESULT of a call we cannot resolve is not thereby a callable. // This branch catches every builtin without a modelled value // (`print`, `listAppend`, …), whose result is plain data; calling @@ -1086,9 +1089,23 @@ impl Analyzer<'_> { // `statically_named_callee` and is reported at that call. return Some(Value::default()); }; - let arguments = - self.argument_values(&known.parameters, arguments, named_arguments, scope, env); - self.called_value_with_values(Callable::Known(known), &arguments) + self.project_call_return(Value::from_callable(callee), arguments) + } + + fn callsite_arguments( + &self, + function: &Expr, + arguments: &[Expr], + named: &[NamedArgument], + scope: &[String], + env: &CallableEnv, + ) -> CallArguments { + let arguments = self.call_arguments(arguments, named, scope, env); + if source_named_callee(function, scope, env, self.index) { + arguments + } else { + arguments.in_written_order() + } } fn call_arguments( @@ -1115,30 +1132,6 @@ impl Analyzer<'_> { } } - fn called_value_with_values( - &self, - callee: Callable, - arguments: &[Option], - ) -> Option { - let Callable::Known(known) = callee else { - return Some(Value::unknown_callable()); - }; - known - .returned - .as_deref() - .cloned() - .map(|returned| self.substitute_value_at(returned, 0, arguments)) - // A known callee with no recorded return provenance says nothing - // about whether its RESULT is callable — most such results are - // ordinary data, and `returned` is also what the depth cutoff drops - // first. Yielding a provenance-free value keeps that distinction: - // it stays fail-closed, because invoking a value with no callable - // still fails `statically_named_callee` at the call and is reported - // there, while an `int` that is merely returned no longer poisons - // every merge it flows into with an unresolved-callable verdict. - .or_else(|| Some(Value::default())) - } - fn builtin_call_value( &self, name: &str, @@ -1320,31 +1313,6 @@ impl Analyzer<'_> { reason = "value provenance mirrors the exhaustive expression fold" )] fn raw_value(&self, expression: &Expr, scope: &[String], env: &CallableEnv) -> Option { - if let Some(parts) = crate::methods::parts(expression) { - return match self - .instances - .methods - .get(&std::ptr::from_ref(expression).addr()) - { - Some(crate::methods::Target::Field(field)) => { - let callee = self - .value(parts.target, scope, env) - .and_then(|value| project_field(value, field)) - .and_then(|value| value.callable); - self.called_value(callee, parts.arguments, parts.named, scope, env) - } - Some(crate::methods::Target::Deferred(field)) => self - .deferred_method(&parts, field, scope, env) - .and_then(|value| self.project_returned(value)), - Some(crate::methods::Target::Function) | None => self.call_value( - &Expr::Identifier(parts.method.to_owned()), - &receiver_first(parts.target, parts.arguments), - parts.named, - scope, - env, - ), - }; - } match expression { Expr::Integer(_) | Expr::Float(_) @@ -1486,16 +1454,24 @@ impl Analyzer<'_> { function, arguments, named_arguments, - } => self.call_value(function, arguments, named_arguments, scope, env), + } => match crate::methods::parts(expression) { + Some(parts) => self.method_value(expression, &parts, scope, env), + None => self.call_value(function, arguments, named_arguments, scope, env), + }, Expr::MethodCall { target, method, arguments, named_arguments, - } => self.call_value( - &Expr::Identifier(method.clone()), - &receiver_first(target, arguments), - named_arguments, + } => self.method_value( + expression, + &crate::methods::Parts { + target, + method, + arguments, + named: named_arguments, + application: None, + }, scope, env, ), @@ -1940,55 +1916,67 @@ impl Analyzer<'_> { fn statements(&self, statements: &[Stmt], scope: &[String], env: &mut CallableEnv) -> Summary { let mut out = Summary::default(); for statement in statements { - match statement { - Stmt::Let { name, value, .. } => { - out.union(self.expression(value, scope, env)); - self.flow_callable_assignments(value, scope, env); - let _ = env.shadowed.insert(name.clone()); - if let Some(provenance) = self.value(value, scope, env) { - let _ = env.values.insert(name.clone(), provenance); - } else { - let _ = env.values.remove(name); - } - } - Stmt::Assignment { name, value, .. } => { - out.union(self.expression(value, scope, env)); - self.flow_callable_assignments(value, scope, env); - if let Some(provenance) = self.value(value, scope, env) { - let _ = env.values.insert(name.clone(), provenance); - } else { - let _ = env.values.remove(name); - } + // `let`, assignment and a bare expression all analyse their value + // and flow its callable assignments; only the two binding forms go + // on to re-point the name. The shadow mark lands AFTER the value is + // analysed, so `let x = f(x)` still sees the outer `x`. + let (name, value) = match statement { + Stmt::Let { name, value, .. } | Stmt::Assignment { name, value, .. } => { + (Some(name), value) } - Stmt::Expr { value, .. } => { - out.union(self.expression(value, scope, env)); - self.flow_callable_assignments(value, scope, env); - } - _ => {} + Stmt::Expr { value, .. } => (None, value), + _ => continue, + }; + out.union(self.expression(value, scope, env)); + self.flow_callable_assignments(value, scope, env); + if let Stmt::Let { name, .. } = statement { + let _ = env.shadowed.insert(name.clone()); + } + if let Some(name) = name { + self.rebind_value(name, value, scope, env); } } out } - fn expressions(&self, expressions: &[Expr], scope: &[String], env: &CallableEnv) -> Summary { + /// Re-point `name` at the provenance of its new `value`, forgetting the old + /// binding when the value carries none — the rebind `let` and assignment + /// share. + fn rebind_value(&self, name: &str, value: &Expr, scope: &[String], env: &mut CallableEnv) { + if let Some(provenance) = self.value(value, scope, env) { + let _ = env.values.insert(name.to_owned(), provenance); + } else { + let _ = env.values.remove(name); + } + } + + /// The union of the rows every expression in `exprs` contributes. Every + /// aggregate form performs this same fold — they differ only in what they + /// hold their expressions in, so each passes its own projection. + fn union_over<'e>( + &self, + exprs: impl IntoIterator, + scope: &[String], + env: &CallableEnv, + ) -> Summary { let mut out = Summary::default(); - for expression in expressions { - out.union(self.expression(expression, scope, env)); + for expr in exprs { + out.union(self.expression(expr, scope, env)); } out } + fn expressions(&self, expressions: &[Expr], scope: &[String], env: &CallableEnv) -> Summary { + self.union_over(expressions, scope, env) + } + fn named_expressions( &self, arguments: &[NamedArgument], scope: &[String], env: &CallableEnv, ) -> Summary { - let mut out = Summary::default(); - for argument in arguments { - out.union(self.expression(&argument.value, scope, env)); - } - out + self.union_over(arguments.iter().map(|argument| &argument.value), scope, env) } } @@ -2010,6 +1998,26 @@ fn expression_name(expression: &Expr) -> Option<&str> { } } +/// Only a declaration resolved at this call site supplies parameter names. +/// A tracked callback can be known while still being called through a slot. +fn source_named_callee( + expression: &Expr, + scope: &[String], + env: &CallableEnv, + index: &Index<'_>, +) -> bool { + match expression { + Expr::TypeApply { function, .. } => source_named_callee(function, scope, env, index), + Expr::Identifier(name) => { + !env.shadowed.contains(name) + && !env.values.contains_key(name) + && index.resolve(scope, name).is_some() + } + Expr::Path(path) => index.resolve(scope, &path.to_string()).is_some(), + _ => false, + } +} + /// Whether a callee this pass could not resolve is nonetheless known to be /// effect-free, so the call may be skipped instead of failing closed. /// @@ -2482,7 +2490,12 @@ fn bind_pattern( for field in fields { let _ = env.shadowed.insert(field.clone()); let projected = value.and_then(|value| { - if name == "Success" && field == "value" { + // Elvis binds the same success payload under a reserved + // name; losing it would discard the successful arm's + // callable effects at the fallback join. [PATTERN-RESULT-DEFAULT] + if name == "Success" + && (field == "value" || field == osprey_ast::RESULT_DEFAULT_PAYLOAD) + { project_success_value(value.clone()) } else { value.fields.get(field).cloned() @@ -3043,7 +3056,7 @@ fn gpu_kernel_verdict( "cannot prove GPU kernel pure; pass a named function or an inline lambda", )); }; - let row = analyzer.invoke(callee, &[], &[], scope, env); + let row = analyzer.invoke_with_values(callee, &[]); if !row.required.is_empty() { let performed: Vec = row.required.iter().map(requirement_name).collect(); return Some(format!( diff --git a/crates/osprey-types/src/effect_rows_transport_tests.rs b/crates/osprey-types/src/effect_rows_transport_tests.rs new file mode 100644 index 00000000..ab94ff5d --- /dev/null +++ b/crates/osprey-types/src/effect_rows_transport_tests.rs @@ -0,0 +1,433 @@ +//! [EFFECTS-STATIC-DISCHARGE] Preserve effects through generic dispatch, +//! higher-order arguments and handler results without capturing authority. + +use crate::effect_rows_tests::{assert_accepted, diagnostics}; +use crate::TypeError; + +const PROBE: &str = "effect Probe { value: fn() -> int }\n\ + fn fetch() -> int !Probe = perform Probe.value()\n\ + fn pure() -> int = 22\n"; +const ACTION: &str = "type Action = Action { m: () -> int }\n"; +const DISPATCH: &str = "fn m(x:T) -> int = 44\nfn dispatch(x:T) = x.m()\n"; +const UNHANDLED: &str = + "unhandled effect operations at program entry: Probe.value; add a matching `handle`"; +const GENERIC_UNHANDLED: &str = + "unhandled effect operations at program entry: Probe.value; add a matching `handle`"; + +fn assert_errors(source: &str, expected: &[&str]) { + assert_eq!( + diagnostics(source), + expected + .iter() + .map(|message| TypeError::new(*message)) + .collect::>(), + "{source}" + ); +} + +fn probe_call(declarations: &str, expression: &str, required: bool) { + let source = format!("{PROBE}{declarations}\nlet answer = {expression}\n"); + assert_errors(&source, if required { &[UNHANDLED] } else { &[] }); + assert_accepted(&format!( + "{PROBE}{declarations}\nlet answer = handle Probe\n value => 33\nin {expression}\n" + )); +} + +#[test] +fn only_the_selected_method_branch_contributes_effects() { + for (field, fallback, field_effectful) in [("fetch", "22", true), ("pure", "fetch()", false)] { + let declarations = format!( + "{ACTION}fn m(x:T) -> int = {fallback}\n\ + fn dispatch(x:T) = x.m()\nlet r = Action{{m:{field}}}\n" + ); + for (call, required) in [ + ("r.m()", field_effectful), + ("dispatch(r)", field_effectful), + ("dispatch(5)", !field_effectful), + ("dispatch(length(\"abc\"))", !field_effectful), + ("dispatch(intDiv(8,2) ?: 0)", !field_effectful), + ] { + probe_call(&declarations, call, required); + } + } +} + +#[test] +fn deferred_method_arguments_keep_positional_and_named_callback_effects() { + for invocation in ["x.m(cb)", "x.m(cb:cb)"] { + let declarations = format!( + "type Action = Action {{m: (() -> int) -> int}}\n\ + fn field(cb: () -> int) -> int = cb()\n\ + fn m(x:T, cb: () -> int) -> int = 22\n\ + fn dispatch(x:T, cb: () -> int) = {invocation}\n" + ); + probe_call(&declarations, "dispatch(Action{m:field},fetch)", true); + probe_call(&declarations, "dispatch(5,fetch)", false); + } +} + +#[test] +fn deferred_methods_preserve_captured_receivers_and_returned_callables() { + let captured = format!("{ACTION}{DISPATCH}fn later(x:T) = fn() -> int => x.m()\n"); + probe_call(&captured, "later(Action{m:fetch})()", true); + probe_call(&captured, "later(5)()", false); + let returned = "type Action = Action {m: () -> () -> int}\n\ + fn field() -> () -> int = fetch\n\ + fn m(x:T) -> () -> int = pure\n\ + fn dispatch(x:T) = x.m()\n"; + for expression in [ + "dispatch(Action{m:field})()", + "Action{m:field}.m()()", + "{let f=dispatch(Action{m:field})\nf()}", + ] { + probe_call(returned, expression, true); + } + probe_call(returned, "dispatch(5)()", false); +} + +#[test] +fn a_handler_inside_a_generic_helper_discharges_only_its_invocation() { + let declarations = format!( + "{ACTION}fn m(x:T) -> int = 22\n\ + fn dispatch(x:T) = handle Probe\n value => 33\nin x.m()\n" + ); + probe_call(&declarations, "dispatch(Action{m:fetch})", false); + probe_call(&declarations, "dispatch(5)", false); + probe_call( + &declarations, + "{let ignored=dispatch(Action{m:fetch})\nfetch()}", + true, + ); +} + +#[test] +fn higher_order_invocation_retains_named_and_curried_arguments() { + for (declarations, invoked, ignored) in [ + ( + "fn call(callback: ()->int) -> int = callback()\n\ + fn ignore(callback: ()->int) -> int = 22\n\ + fn through(f: (()->int)->int, callback: ()->int) -> int = f(callback)\n", + "through(call,fetch)", + "through(ignore,fetch)", + ), + ( + "fn call(callback: ()->int) -> int = callback()\n\ + fn ignore(callback: ()->int) -> int = 22\n\ + fn through(f: (()->int)->int, callback: ()->int) -> int = f(callback:callback)\n", + "through(callback:fetch,f:call)", + "through(callback:fetch,f:ignore)", + ), + ( + "fn call(callback: ()->int) -> (int)->int = fn(x:int) => callback()\n\ + fn ignore(callback: ()->int) -> (int)->int = fn(x:int) => 22\n\ + fn through(f: (()->int)->(int)->int, callback: ()->int) -> int = f(callback)(1)\n", + "through(call,fetch)", + "through(ignore,fetch)", + ), + ] { + probe_call(declarations, invoked, true); + probe_call(declarations, ignored, false); + } +} + +#[test] +fn a_parameter_returning_a_record_keeps_actual_argument_provenance() { + for (maker, forwarding, call, required) in [ + ( + "fn make(cb: ()->int) -> Action = Action{m:cb}", + "fn through(makeFn: (()->int)->Action) = dispatch(makeFn(fetch))", + "through(make)", + true, + ), + ( + "fn identity(x:Action) -> Action = x", + "fn through(makeFn: (Action)->Action) = dispatch(makeFn(Action{m:fetch}))", + "through(identity)", + true, + ), + ( + "fn identity(x:Action) -> Action = x", + "fn through(makeFn: (Action)->Action) = dispatch(makeFn(x:Action{m:fetch}))", + "through(identity)", + true, + ), + ( + "fn make(x:int) -> (int)->Action = fn(y:int) => Action{m:fetch}", + "fn through(makeFn: (int)->(int)->Action) = dispatch(makeFn(1)(2))", + "through(make)", + true, + ), + ( + "fn make(cb: ()->int) -> Action = Action{m:pure}", + "fn through(makeFn: (()->int)->Action) = dispatch(makeFn(fetch))", + "through(make)", + false, + ), + ] { + probe_call( + &format!("{ACTION}{DISPATCH}{maker}\n{forwarding}\n"), + call, + required, + ); + } +} + +#[test] +fn builtin_shadowing_obeys_the_actual_function_local_or_parameter() { + for (declarations, call) in [ + ( + "fn test(x:int) -> Action = Action{m:fetch}", + "dispatch(test(1))", + ), + ("let test = |x| => Action{m:fetch}", "dispatch(test(1))"), + ( + "fn make(x:int) -> Action = Action{m:fetch}\n\ + fn through(test: (int)->Action) = dispatch(test(1))", + "through(make)", + ), + ( + "fn make(x:int) -> Action = Action{m:fetch}\n\ + fn through(makeFn: (int)->Action) = dispatch(makeFn(1))", + "through(make)", + ), + ] { + probe_call(&format!("{ACTION}{DISPATCH}{declarations}\n"), call, true); + } + for (declarations, call) in [ + ( + "fn test(name:string, f:()->int) -> int = 22", + "test(\"ignored\",fetch)", + ), + ("let test = |name,f| => 22", "test(\"ignored\",fetch)"), + ( + "fn ignore(name:string, f:()->int) -> int = 22\n\ + fn through(test: (string,()->int)->int) = test(\"ignored\",fetch)", + "through(ignore)", + ), + ] { + probe_call(declarations, call, false); + } + probe_call( + "fn callback() = print(fetch())\n", + "test(\"eager\",callback)", + true, + ); +} + +const GENERIC_FACTORY: &str = "type Action = Action {m: () -> int}\n\ + effect Probe {value: fn() -> T}\n\ + effect Factory {make: fn() -> T}\n\ + fn fetch() -> int !Probe = perform Probe.value()\n\ + fn pure() -> int = 22\nfn extract(x:T) = x.m\n"; + +#[test] +fn generic_handler_results_cannot_be_rebound_to_an_unrelated_caller_argument() { + for body in [ + "extract(perform Factory.make())", + "{let record=perform Factory.make()\nfn() => extract(record)()}", + ] { + for unrelated in ["pure", "fetch"] { + let declarations = format!( + "{GENERIC_FACTORY}fn get(dummy:Action) = handle Factory\n\ + make => Action{{m:fetch}}\nin {body}\nlet f=get(Action{{m:{unrelated}}})\n" + ); + assert_errors( + &format!("{declarations}let answer=f()\n"), + &[GENERIC_UNHANDLED], + ); + assert_accepted(&format!( + "{declarations}let answer=handle Probe\nvalue=>33\nin f()\n" + )); + assert_errors( + &format!("{declarations}let answer=handle Probe\nvalue=>\"wrong\"\nin f()\n"), + &[GENERIC_UNHANDLED], + ); + } + } +} + +#[test] +fn handler_result_provenance_respects_local_shadowing_and_pure_results() { + for (local, returned) in [("", "pure"), ("let fetch=fn() -> int => 22", "fetch")] { + assert_accepted(&format!( + "{GENERIC_FACTORY}fn get(dummy:Action) = {{\n{local}\n\ + handle Factory\nmake => Action{{m:{returned}}}\nin extract(perform Factory.make())\n\ + }}\nlet f=get(Action{{m:fetch}})\nlet answer=f()\n" + )); + } +} + +#[test] +fn escaped_closures_capture_values_but_never_active_handler_bindings() { + assert_errors( + &format!("{ACTION}{PROBE}effect Factory {{make: fn() -> Action}}\n\ + fn extract(x:T) = x.m\n\ + let f=handle Factory\nmake=>Action{{m:pure}}\n\ + in fn()=>extract(perform Factory.make())()\nlet answer=f()\n"), + &[ + "unhandled effect operations at program entry: Factory.make; add a matching `handle`", + "program entry invokes a dynamic callable whose effect provenance cannot be proven; preserve the callable through a statically tracked value path", + ], + ); +} + +#[test] +fn merging_results_and_fibers_keeps_every_callback_requirement() { + for callback in ["fetch", "pure"] { + for (declarations, expression) in [ + ( + format!( + "fn choose(flag) -> Result<()->int, Error> = match flag {{\n\ + true => Success{{value:{callback}}}\nfalse => Success{{value:pure}}\n}}\n" + ), + "(choose(true) ?: pure)()", + ), + ( + format!( + "fn choose(flag) = match flag {{\n\ + true => spawn {callback}\nfalse => spawn pure\n}}\n\ + fn unpack(fiber: Fiber) -> T = await(fiber)\n" + ), + "unpack(choose(true))()", + ), + ] { + probe_call(&declarations, expression, callback == "fetch"); + } + } +} + +#[test] +fn computed_builtin_containers_select_the_generic_free_function() { + for expression in [ + "dispatch(mapKeys(mapSet(Map(),\"x\",1)))", + "dispatch(toGpu([1,2]))", + "dispatch(fromGpu(toGpu([1,2])))", + "dispatch(gpuIota(2))", + ] { + probe_call(DISPATCH, expression, false); + probe_call( + "fn m(x:T) -> int = fetch()\nfn dispatch(x:T) = x.m()\n", + expression, + true, + ); + } +} + +#[test] +fn a_unit_field_update_preserves_other_callable_fields() { + for callback in ["fetch", "pure"] { + probe_call( + &format!( + "type Entry = Entry {{m: ()->int, flag: Unit}}\n\ + let original=Entry{{m:{callback},flag:print(\"\")}}\n\ + let updated=original{{flag:yield}}\n" + ), + "updated.m()", + callback == "fetch", + ); + } +} + +#[test] +fn an_opaque_iterator_element_cannot_select_a_pure_method_fallback() { + let declarations = format!( + "{PROBE}{ACTION}{DISPATCH}\n\ + let items=map(range(0,1),fn(n)=>Action{{m:fetch}})\n" + ); + for invocation in ["item.m()", "dispatch(item)"] { + assert_errors( + &format!("{declarations}forEach(items,fn(item)=>print({invocation}))\n"), + &["program entry invokes a dynamic callable whose effect provenance cannot be proven; preserve the callable through a statically tracked value path"], + ); + } + probe_call( + &format!("{ACTION}{DISPATCH}let items=[Action{{m:fetch}}]\n"), + "dispatch(listGet(items,0) ?: Action{m:pure})", + true, + ); +} + +#[test] +fn a_callback_parameter_field_keeps_its_invocation_effects() { + let declarations = format!( + "{ACTION}{DISPATCH}\n\ + fn forward(dummy:T,cb:()->int)=dispatch(Action{{m:cb}})\n" + ); + probe_call(&declarations, "forward(0,pure)", false); + probe_call(&declarations, "forward(0,fetch)", true); +} + +#[test] +fn a_callback_parameter_field_preserves_its_returned_callable() { + for declarations in [ + "type Factory=Factory{m:()->()->int}\n\ + fn pureFactory()->()->int=pure\nfn effectFactory()->()->int=fetch\n\ + fn m(x:T)->()->int=pure\nfn dispatch(x:T)=x.m()\n\ + fn forward(dummy:T,cb:()->()->int)=dispatch(Factory{m:cb})()\n", + "type Factory=Factory{m:(()->int,()->int)->()->int}\n\ + fn pureFactory(callback:()->int,ignored:()->int)->()->int=callback\n\ + fn effectFactory(callback:()->int,ignored:()->int)->()->int=ignored\n\ + fn m(x:T,callback:()->int,ignored:()->int)->()->int=pure\n\ + fn dispatch(x:T)=x.m(ignored:pure,callback:fetch)\n\ + fn forward(dummy:T,cb:(()->int,()->int)->()->int)=dispatch(Factory{m:cb})()\n", + ] { + probe_call(declarations, "forward(0,pureFactory)", false); + probe_call(declarations, "forward(0,effectFactory)", true); + } +} + +#[test] +fn named_function_value_calls_bind_written_slots_before_callback_substitution() { + let declarations = "fn first(callback:()->int,ignored:()->int)->int=callback()\n\ + fn second(callback:()->int,ignored:()->int)->int=ignored()\n\ + fn through(f:(()->int,()->int)->int)=f(ignored:pure,callback:fetch)\n\ + fn throughGeneric(dummy:T,f:(()->int,()->int)->int)=f(ignored:pure,callback:fetch)\n\ + type Action=Action{m:(()->int,()->int)->int}\n\ + fn m(x:T,callback:()->int,ignored:()->int)->int=callback()\n\ + fn dispatch(x:T)=x.m(ignored:pure,callback:fetch)\n"; + for (expression, required) in [ + ("first(ignored:pure,callback:fetch)", true), + ("second(ignored:pure,callback:fetch)", false), + ("through(first)", false), + ("through(second)", true), + ("throughGeneric(0,first)", false), + ("throughGeneric(0,second)", true), + ("{let f=first\nf(ignored:pure,callback:fetch)}", false), + ("{let f=second\nf(ignored:pure,callback:fetch)}", true), + ("Action{m:first}.m(ignored:pure,callback:fetch)", false), + ("Action{m:second}.m(ignored:pure,callback:fetch)", true), + ("dispatch(Action{m:first})", false), + ("dispatch(Action{m:second})", true), + ("dispatch(0)", true), + ] { + probe_call(declarations, expression, required); + } +} + +#[test] +fn rejected_named_performs_still_report_the_handlers_callback_effects() { + let declarations = "effect Callback {go: fn(()->int)->int}\n"; + let unsupported = "perform `Callback.go` does not support named arguments"; + for (callback, expected) in [ + ("pure", vec![unsupported]), + ("fetch", vec![unsupported, UNHANDLED]), + ] { + let invocation = + format!("handle Callback\n go cb => cb()\nin perform Callback.go(cb:{callback})"); + assert_errors( + &format!("{PROBE}{declarations}let answer={invocation}\n"), + &expected, + ); + assert_errors( + &format!( + "{PROBE}{declarations}let answer=handle Probe\n value => 33\nin {invocation}\n" + ), + &[unsupported], + ); + } + probe_call( + declarations, + "handle Callback\n go cb => cb()\nin perform Callback.go(fetch)", + true, + ); +} diff --git a/crates/osprey-types/src/env.rs b/crates/osprey-types/src/env.rs index 7127cb60..da1eeccc 100644 --- a/crates/osprey-types/src/env.rs +++ b/crates/osprey-types/src/env.rs @@ -18,7 +18,7 @@ pub(crate) struct AppliedSignature { /// Maps names to their type schemes. Cloned to form child scopes (lambda /// bodies, match arms) — value semantics, so child bindings never leak out. #[derive(Debug, Clone, Default)] -pub struct TypeEnv { +pub(crate) struct TypeEnv { vars: HashMap, /// Ordered declaration binders, cleared whenever a value shadows a name. type_params: HashMap>, @@ -27,15 +27,15 @@ pub struct TypeEnv { } impl TypeEnv { - pub fn new() -> TypeEnv { + pub(crate) fn new() -> TypeEnv { TypeEnv::default() } - pub fn get(&self, name: &str) -> Option<&Scheme> { + pub(crate) fn get(&self, name: &str) -> Option<&Scheme> { self.vars.get(name) } - pub fn insert(&mut self, name: impl Into, scheme: Scheme) { + pub(crate) fn insert(&mut self, name: impl Into, scheme: Scheme) { let name = name.into(); // A fresh binding shadows any outer `mut` of the same name. let _ = self.mutables.remove(&name); @@ -44,24 +44,24 @@ impl TypeEnv { } /// Bind a `mut` declaration — the one binding form handler arms may assign. - pub fn insert_mutable(&mut self, name: impl Into, scheme: Scheme) { + pub(crate) fn insert_mutable(&mut self, name: impl Into, scheme: Scheme) { let name = name.into(); let _ = self.type_params.remove(&name); let _ = self.vars.insert(name.clone(), scheme); let _ = self.mutables.insert(name); } - pub fn is_mutable(&self, name: &str) -> bool { + pub(crate) fn is_mutable(&self, name: &str) -> bool { self.mutables.contains(name) } /// The currently bound names. Snapshotted on the freshly built builtin /// environment to detect redefinition of built-in functions. - pub fn bound_names(&self) -> HashSet { + pub(crate) fn bound_names(&self) -> HashSet { self.vars.keys().cloned().collect() } - pub fn remove(&mut self, name: &str) { + pub(crate) fn remove(&mut self, name: &str) { let _ = self.vars.remove(name); let _ = self.type_params.remove(name); } @@ -82,11 +82,7 @@ impl TypeEnv { .flatten() .map(|ty| subst_vars(&ctx.apply(ty), &map)) .collect(); - let obligations = scheme - .obligations - .iter() - .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))) - .collect(); + let obligations = subst_obligations(&scheme.obligations, &map); Some(AppliedSignature { ty: subst_vars(&scheme.ty, &map), obligations, @@ -96,13 +92,13 @@ impl TypeEnv { } /// A fresh child scope (a clone — bindings added to the child don't leak). - pub fn child(&self) -> TypeEnv { + pub(crate) fn child(&self) -> TypeEnv { self.clone() } /// The free variables of the whole environment — the vars `generalize` must /// *not* quantify, because an outer scope may still constrain them. - pub fn free_vars(&self, ctx: &mut InferCtx) -> BTreeSet { + pub(crate) fn free_vars(&self, ctx: &mut InferCtx) -> BTreeSet { let mut out = BTreeSet::new(); for scheme in self.vars.values() { let mut fv = BTreeSet::new(); @@ -119,8 +115,20 @@ impl TypeEnv { } } +/// A scheme's built-in obligations restated against the substitution `map` — +/// the same rewrite every instantiation site performs on its fresh variables. +fn subst_obligations( + obligations: &[(String, Type)], + map: &HashMap, +) -> Vec<(String, Type)> { + obligations + .iter() + .map(|(name, ty)| (name.clone(), subst_vars(ty, map))) + .collect() +} + /// Instantiate a scheme: replace each quantified variable with a fresh one. -pub fn instantiate(ctx: &mut InferCtx, scheme: &Scheme) -> Type { +pub(crate) fn instantiate(ctx: &mut InferCtx, scheme: &Scheme) -> Type { instantiated(ctx, scheme).0 } @@ -129,21 +137,17 @@ pub fn instantiate(ctx: &mut InferCtx, scheme: &Scheme) -> Type { /// against the concrete types it supplies — a generalized wrapper cannot /// launder an ineligible element type past a constrained built-in /// ([`Scheme::obligations`]). -pub fn instantiated(ctx: &mut InferCtx, scheme: &Scheme) -> (Type, Vec<(String, Type)>) { +pub(crate) fn instantiated(ctx: &mut InferCtx, scheme: &Scheme) -> (Type, Vec<(String, Type)>) { if scheme.vars.is_empty() { return (scheme.ty.clone(), scheme.obligations.clone()); } let map: HashMap = scheme.vars.iter().map(|v| (*v, ctx.fresh())).collect(); - let obligations = scheme - .obligations - .iter() - .map(|(name, ty)| (name.clone(), subst_vars(ty, &map))) - .collect(); + let obligations = subst_obligations(&scheme.obligations, &map); (subst_vars(&scheme.ty, &map), obligations) } /// Generalize a type over the variables free in it but not in the environment. -pub fn generalize(ctx: &mut InferCtx, env: &TypeEnv, ty: &Type) -> Scheme { +pub(crate) fn generalize(ctx: &mut InferCtx, env: &TypeEnv, ty: &Type) -> Scheme { let ty = ctx.apply(ty); let env_fv = env.free_vars(ctx); let mut ty_fv = BTreeSet::new(); diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index 57814ce1..81546735 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -218,21 +218,31 @@ impl Checker { &Type::con(names::CHANNEL, vec![element_ty.clone()]), ); self.push_assign(&element_ty, &value_ty); - if self.ctx.prune(&value_ty).is_named(names::RESULT) { - self.errors.push(TypeError::new( - "Result-valued channels are not supported by this backend; handle the Result before sending", - )); - } + self.reject_result_channel(&value_ty, "handle the Result before sending"); Type::unit() } + /// Reject a `Result`-valued channel element. The wire word carries no + /// discriminant, so a `Result` crossing a channel would be erased rather + /// than delivered — both ends refuse it, differing only in which half of + /// the transfer the advice names. + fn reject_result_channel(&mut self, ty: &Type, detail: &str) { + if self.ctx.prune(ty).is_named(names::RESULT) { + self.errors.push(TypeError::new(format!( + "Result-valued channels are not supported by this backend; {detail}" + ))); + } + } + + /// Record how the dotted call at `site` resolved, keyed by the expression's + /// address — the one place the method-target table is written. + fn record_method_target(&mut self, site: &Expr, target: crate::methods::Target) { + let _ = self.methods.insert(std::ptr::from_ref(site).addr(), target); + } + fn infer_recv(&mut self, channel: &Expr, env: &TypeEnv) -> Type { let elem = self.infer_unwrap_con(channel, names::CHANNEL, env); - if self.ctx.prune(&elem).is_named(names::RESULT) { - self.errors.push(TypeError::new( - "Result-valued channels are not supported by this backend; receiving must never erase the Result wrapper", - )); - } + self.reject_result_channel(&elem, "receiving must never erase the Result wrapper"); elem } @@ -449,9 +459,9 @@ impl Checker { // [EFFECTS-GENERIC-INSTANTIATION]. if osprey_ast::contains_resume(&arm.body) { answering.push((arm.operation.clone(), arm_ty)); - } else if !self.ctx.prune(&op_ret).is_named(crate::ty::names::UNIT) { + } else if !self.ctx.prune(&op_ret).is_named(names::UNIT) { self.push_assign(&op_ret, &arm_ty); - } else if self.ctx.prune(&arm_ty).is_named(crate::ty::names::RESULT) { + } else if self.ctx.prune(&arm_ty).is_named(names::RESULT) { self.errors.push(TypeError::new( "an unhandled `Result` cannot be discarded by a Unit effect operation arm; use `match` or `?:`", )); @@ -576,7 +586,7 @@ impl Checker { fn infer_type_application( &mut self, function: &Expr, - type_args: &[osprey_ast::TypeExpr], + type_args: &[TypeExpr], position: Option, env: &TypeEnv, ) -> (Option, Type) { @@ -628,7 +638,7 @@ impl Checker { /// application of an enclosing binder [TYPE-GENERICS-APPLY]. pub(crate) fn written_type_argument( &mut self, - argument: &osprey_ast::TypeExpr, + argument: &TypeExpr, binder: &HashMap, position: Option, ) -> Type { @@ -641,7 +651,7 @@ impl Checker { /// that conversion would otherwise silently drop [TYPE-GENERICS-FN]. pub(crate) fn annotation_type( &mut self, - argument: &osprey_ast::TypeExpr, + argument: &TypeExpr, binder: &HashMap, position: Option, ) -> Type { @@ -730,10 +740,7 @@ impl Checker { let receiver = self.infer_expr(parts.target, env); let field = crate::methods::field_name(parts.method); if matches!(self.ctx.prune(&receiver), Type::Var(_)) && env.get(parts.method).is_some() { - let _ = self.methods.insert( - std::ptr::from_ref(site).addr(), - crate::methods::Target::Deferred(field.clone()), - ); + self.record_method_target(site, crate::methods::Target::Deferred(field.clone())); return self.infer_deferred_method(site, receiver, &field, &parts, env); } let known_field = match self.ctx.prune(&receiver) { @@ -746,17 +753,11 @@ impl Checker { _ => false, }; if known_field { - let _ = self.methods.insert( - std::ptr::from_ref(site).addr(), - crate::methods::Target::Field(field.clone()), - ); + self.record_method_target(site, crate::methods::Target::Field(field.clone())); return self.infer_field_call(&receiver, &field, &parts, env); } if env.get(parts.method).is_some() { - let _ = self.methods.insert( - std::ptr::from_ref(site).addr(), - crate::methods::Target::Function, - ); + self.record_method_target(site, crate::methods::Target::Function); } self.infer_ufcs_call(site, &receiver, &parts, env) } @@ -1255,7 +1256,7 @@ impl Checker { fn infer_constructor( &mut self, name: &str, - type_args: &[osprey_ast::TypeExpr], + type_args: &[TypeExpr], fields: &[FieldAssignment], env: &TypeEnv, ) -> Type { @@ -1658,7 +1659,7 @@ fn classify(op: &str) -> OpKind { #[cfg(test)] mod tests { use crate::check::check_program; - use crate::testutil::{bad, check, ok}; + use crate::testutil::{bad, bad_with, ok}; use crate::{infer_program, Type}; use osprey_ast::Stmt; use osprey_syntax::parse_program; @@ -1730,23 +1731,23 @@ mod tests { #[test] fn select_is_rejected_until_channel_selection_has_runtime_semantics() { - let errs = bad("fn pick() -> int = select {\n\ + bad_with( + "fn pick() -> int = select {\n\ x => x\n\ _ => 0\n\ - }\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("`select` is not supported"))); + }\n", + "`select` is not supported", + ); } #[test] fn yield_forwards_its_value_type_and_send_checks_the_channel_element() { // Implements [CONCURRENCY-YIELD] and [CONCURRENCY-CHANNEL]. ok("fn hand_off(value: int) -> int = yield value\n"); - let errs = bad("fn wrong(ch: Channel) -> Unit = send(ch, \"wrong\")\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("cannot unify int with string"))); + bad_with( + "fn wrong(ch: Channel) -> Unit = send(ch, \"wrong\")\n", + "cannot unify int with string", + ); let result_channel = bad( "fn sendFailed(ch: Channel>, value: Result) -> Unit = send(ch, value)\n", ); @@ -1842,14 +1843,14 @@ mod tests { // A `Unit` operation discards its arm's value, so a `Result` produced // there would lose its failure with nothing left to observe it. // Implements [EFFECTS-RESUME]. - let errs = bad("effect Sink { drop: fn(int) -> Unit }\n\ + bad_with( + "effect Sink { drop: fn(int) -> Unit }\n\ fn risky(n: int) -> Result = n + 1\n\ fn go() -> int = handle Sink\n\ drop v => risky(v)\n\ - in 0\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("Unit effect operation arm"))); + in 0\n", + "Unit effect operation arm", + ); ok("effect Sink { drop: fn(int) -> Unit }\n\ fn risky(n: int) -> Result = n + 1\n\ fn go() -> int = handle Sink\n\ @@ -1862,20 +1863,20 @@ mod tests { // The handler's own operations are unknown, so the arms cannot be // typed against a signature — but checking must continue rather than // abandon the body, or one typo would hide every later diagnostic. - let errs = bad("fn go() -> int = handle Nowhere\n\ + bad_with( + "fn go() -> int = handle Nowhere\n\ chime => 0\n\ - in 1\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("unknown effect `Nowhere`"))); + in 1\n", + "unknown effect `Nowhere`", + ); } #[test] fn perform_of_an_undeclared_effect_names_the_effect_it_could_not_find() { - let errs = bad("fn ring() -> int = perform Nowhere.chime()\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("unknown effect `Nowhere`"))); + bad_with( + "fn ring() -> int = perform Nowhere.chime()\n", + "unknown effect `Nowhere`", + ); } #[test] @@ -1885,11 +1886,11 @@ mod tests { // a silently ignored annotation. ok("type Box = { v: T }\n\ let good = Box { v: 1 }\n"); - let errs = bad("type Box = { v: T }\n\ - let wrong = Box { v: 1 }\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("takes 1 type argument(s), got 2"))); + bad_with( + "type Box = { v: T }\n\ + let wrong = Box { v: 1 }\n", + "takes 1 type argument(s), got 2", + ); } #[test] @@ -1899,12 +1900,12 @@ mod tests { // graph to bind the qualified name, so the diagnostic must name the // full path — naming only `twice` would send the reader to the wrong // declaration. - let errs = bad("namespace tools;\n\ + bad_with( + "namespace tools;\n\ fn twice(n: int) -> int = (n * 2) ?: 0\n\ - let doubled = tools::twice(21)\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("unknown identifier `tools::twice`"))); + let doubled = tools::twice(21)\n", + "unknown identifier `tools::twice`", + ); } #[test] @@ -2302,11 +2303,11 @@ mod tests { // Codegen has no named-operation argument mapping; reject this source // form instead of silently dropping its value. // [EFFECTS-OP-TYPING] - let errs = bad("effect Logger { log: fn(string) -> Unit }\n\ - fn run() -> Unit !Logger = perform Logger.log(msg: \"hi\")\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("does not support named arguments"))); + bad_with( + "effect Logger { log: fn(string) -> Unit }\n\ + fn run() -> Unit !Logger = perform Logger.log(msg: \"hi\")\n", + "does not support named arguments", + ); } #[test] @@ -2354,10 +2355,10 @@ mod tests { #[test] fn unknown_constructor_with_fields_is_an_error() { - let errs = check("let r = Nonexistent { field: 1 }\n"); - assert!(errs - .iter() - .any(|e| e.message.contains("unknown constructor `Nonexistent`"))); + bad_with( + "let r = Nonexistent { field: 1 }\n", + "unknown constructor `Nonexistent`", + ); } #[test] @@ -2377,8 +2378,7 @@ mod tests { // bare identifier, so `infer_call` takes the `other` branch. ok("let r = (fn(x) => x + 1)(41)\n"); // Calling a non-function value is an error (`apply_fn` non-function arm). - let errs = check("let x = 5\nlet r = x(1)\n"); - assert!(errs.iter().any(|e| e.message.contains("cannot call"))); + bad_with("let x = 5\nlet r = x(1)\n", "cannot call"); } #[test] diff --git a/crates/osprey-types/src/generic_effects_tests.rs b/crates/osprey-types/src/generic_effects_tests.rs index 0f9eea4e..b4a55c6e 100644 --- a/crates/osprey-types/src/generic_effects_tests.rs +++ b/crates/osprey-types/src/generic_effects_tests.rs @@ -14,8 +14,8 @@ //! spelling is reserved for `static effect`, where the instantiation IS the //! identity. -use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position_message}; -use osprey_syntax::Flavor; +use crate::testutil::{spec_cases, variance_position_message}; +use osprey_syntax::{parse_program_with_flavor, Flavor}; /// The position diagnostic for an effect declaration's OPERATION. fn op_position_message(param: &str, marker: &str, position: &str, op: &str, owner: &str) -> String { @@ -44,118 +44,66 @@ fn main() -> Unit = {{ // [EFFECTS-GENERIC-DECL] — operation parameters are inputs, results outputs // --------------------------------------------------------------------------- -/// "An effect may declare type parameters, including `in` and `out` variance." -#[test] -fn a_generic_effect_declares_type_parameters() { - accepts( - Flavor::Default, - r#"effect Stash { +spec_cases! { + /// "An effect may declare type parameters, including `in` and `out` variance." + a_generic_effect_declares_type_parameters: accepts(Default, r#"effect Stash { put: fn(T) -> Unit take: fn() -> T } -print("declared")"#, - ); -} +print("declared")"#); -/// An operation RESULT is an output position: `out T` belongs there. -#[test] -fn out_is_legal_in_an_operation_result() { - accepts( - Flavor::Default, - r#"effect Source { + /// An operation RESULT is an output position: `out T` belongs there. + out_is_legal_in_an_operation_result: accepts(Default, r#"effect Source { next: fn() -> T } -print("declared")"#, - ); -} +print("declared")"#); -/// An operation PARAMETER is an input position: `out T` is rejected. -#[test] -fn out_in_an_operation_parameter_is_rejected() { - rejects_with( - Flavor::Default, - r#"effect Bad { + /// An operation PARAMETER is an input position: `out T` is rejected. + out_in_an_operation_parameter_is_rejected: rejects_with(Default, r#"effect Bad { send: fn(T) -> Unit } -print("declared")"#, - &op_position_message("T", "out", "input", "send", "Bad"), - ); -} +print("declared")"#, op_position_message("T", "out", "input", "send", "Bad")); -/// The contravariant mirror: `in T` belongs in an operation parameter. -#[test] -fn in_is_legal_in_an_operation_parameter() { - accepts( - Flavor::Default, - r#"effect Sink { + /// The contravariant mirror: `in T` belongs in an operation parameter. + in_is_legal_in_an_operation_parameter: accepts(Default, r#"effect Sink { send: fn(T) -> Unit } -print("declared")"#, - ); -} +print("declared")"#); -/// …and is rejected in an operation result. -#[test] -fn in_in_an_operation_result_is_rejected() { - rejects_with( - Flavor::Default, - r#"effect Bad { + /// …and is rejected in an operation result. + in_in_an_operation_result_is_rejected: rejects_with(Default, r#"effect Bad { next: fn() -> T } -print("declared")"#, - &op_position_message("T", "in", "output", "next", "Bad"), - ); -} +print("declared")"#, op_position_message("T", "in", "output", "next", "Bad")); -/// An invariant parameter sits in either position. -#[test] -fn an_invariant_effect_parameter_is_legal_in_both_positions() { - accepts( - Flavor::Default, - r#"effect Stash { + /// An invariant parameter sits in either position. + an_invariant_effect_parameter_is_legal_in_both_positions: accepts(Default, r#"effect Stash { put: fn(T) -> Unit take: fn() -> T } -print("declared")"#, - ); -} +print("declared")"#); -/// Two binders on one effect are independent. -#[test] -fn an_effect_may_declare_two_binders() { - accepts( - Flavor::Default, - r#"effect Table { + /// Two binders on one effect are independent. + an_effect_may_declare_two_binders: accepts(Default, r#"effect Table { get: fn(K) -> V } -print("declared")"#, - ); +print("declared")"#); } // --------------------------------------------------------------------------- // [EFFECTS-GENERIC-INSTANTIATION] — the written instantiation // --------------------------------------------------------------------------- -/// "Each handler site instantiates a generic effect independently." -#[test] -fn a_written_instantiation_is_accepted_on_handle_and_perform() { - accepts(Flavor::Default, &stash_program("9")); -} +spec_cases! { + /// "Each handler site instantiates a generic effect independently." + a_written_instantiation_is_accepted_on_handle_and_perform: accepts(Default, stash_program("9")); -/// The same program at a different instantiation. -#[test] -fn a_written_string_instantiation_is_accepted() { - accepts(Flavor::Default, &stash_program("\"ready\"")); -} + /// The same program at a different instantiation. + a_written_string_instantiation_is_accepted: accepts(Default, stash_program("\"ready\"")); -/// "Handler arm values and performs in the handled body must agree on that -/// instantiation" — an arm answering `string` cannot serve a body whose result -/// is used as an `int`. -#[test] -fn a_handler_arm_disagreeing_with_the_body_is_rejected() { - rejects_with( - Flavor::Default, - r#"effect Stash { + /// A handler answering `string` cannot discharge the independently inferred + /// `Stash.take` requirement of a helper ([EFFECTS-GENERIC-RUNTIME]). + a_handler_arm_disagreeing_with_the_body_is_rejected: rejects_with(Default, r#"effect Stash { take: fn() -> T } fn doubled() -> int = (perform Stash.take()) * 2 ?: 0 @@ -164,15 +112,10 @@ fn main() -> Unit = { take => "ready" in doubled() print("${held}") -}"#, - "cannot unify", - ); -} +}"#, "unhandled effect operations at program entry: Stash.take"); -/// The instantiation may also be left to inference at both sites. -#[test] -fn an_inferred_instantiation_is_accepted() { - accepts(Flavor::Default, &stash_program("9")); + /// The instantiation may also be left to inference at both sites. + an_inferred_instantiation_is_accepted: accepts(Default, stash_program("9")); } /// A written instantiation on a DYNAMIC effect's `perform` is rejected outright @@ -181,8 +124,7 @@ fn an_inferred_instantiation_is_accepted() { /// `examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo`). #[test] fn a_written_instantiation_on_a_dynamic_perform_is_rejected() { - rejects_with( - Flavor::Default, + let parsed = parse_program_with_flavor( r#"effect Stash { take: fn() -> T } @@ -192,16 +134,21 @@ fn main() -> Unit = { in perform Stash.take() print("${held}") }"#, - "names an instantiation of dynamic effect", + Flavor::Default, + ); + assert_eq!(parsed.errors.len(), 1, "{:?}", parsed.errors); + assert!( + parsed.errors.iter().any(|error| error + .message + .starts_with("`perform Stash` names an instantiation of dynamic effect `Stash`")), + "{:?}", + parsed.errors ); } -/// The same restriction at the `handle` site. -#[test] -fn a_written_instantiation_on_a_dynamic_handle_is_rejected() { - rejected_somehow( - Flavor::Default, - r#"effect Stash { +spec_cases! { + /// The same restriction at the `handle` site. + a_written_instantiation_on_a_dynamic_handle_is_rejected: rejected_somehow(Default, r#"effect Stash { take: fn() -> T } fn main() -> Unit = { @@ -209,17 +156,11 @@ fn main() -> Unit = { take => 9 in perform Stash.take() print("${held}") -}"#, - ); -} +}"#); -/// A handler discharges only the instantiation it was INFERRED at: a handler -/// answering `int` does not serve a `Stash.put`. -#[test] -fn an_inferred_handler_instantiation_discharges_only_its_own_operations() { - rejected_somehow( - Flavor::Default, - r#"effect Stash { + /// A handler discharges only the instantiation it was INFERRED at: a handler + /// answering `int` does not serve a `Stash.put`. + an_inferred_handler_instantiation_discharges_only_its_own_operations: rejected_somehow(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() = perform Stash.put("text") @@ -228,17 +169,11 @@ fn main() -> Unit = { put v => print("stored ${v + 1 ?: 0}") in store() print("${done}") -}"#, - ); -} +}"#); -/// Two handlers at two instantiations coexist in ONE program: "Each handler -/// site instantiates a generic effect independently", and each infers its own. -#[test] -fn two_instantiations_of_one_effect_coexist() { - accepts( - Flavor::Default, - r#"effect Stash { + /// Two handlers at two instantiations coexist in ONE program: "Each handler + /// site instantiates a generic effect independently", and each infers its own. + two_instantiations_of_one_effect_coexist: accepts(Default, r#"effect Stash { take: fn() -> T } fn main() -> Unit = { @@ -249,17 +184,11 @@ fn main() -> Unit = { take => "one" in perform Stash.take() print("${n}${s}") -}"#, - ); -} +}"#); -/// A row's written instantiation IS checked for arity — the row is the surface -/// that keeps the angle spelling, so the count contract lives there. -#[test] -fn an_effect_row_instantiation_arity_is_checked() { - rejected_somehow( - Flavor::Default, - r#"effect Stash { + /// A row's written instantiation IS checked for arity — the row is the surface + /// that keeps the angle spelling, so the count contract lives there. + an_effect_row_instantiation_arity_is_checked: rejected_somehow(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() -> Unit !Stash = perform Stash.put(42) @@ -268,21 +197,17 @@ fn main() -> Unit = { put v => print("stored") in store() print("${done}") -}"#, - ); +}"#); } // --------------------------------------------------------------------------- // [EFFECTS-GENERIC-ROWS] — a row entry pins an instantiation // --------------------------------------------------------------------------- -/// "A row entry such as `!Stash` pins the generic effect instantiation -/// used by performs in that function body." -#[test] -fn a_row_entry_pins_the_instantiation() { - accepts( - Flavor::Default, - r#"effect Stash { +spec_cases! { + /// "A row entry such as `!Stash` pins the generic effect instantiation + /// used by performs in that function body." + a_row_entry_pins_the_instantiation: accepts(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() -> Unit !Stash = perform Stash.put(42) @@ -291,16 +216,10 @@ fn main() -> Unit = { put v => print("stored ${v}") in store() print("${done}") -}"#, - ); -} +}"#); -/// A body contradicting its own pinned row is rejected, naming the row. -#[test] -fn a_body_contradicting_its_pinned_row_is_rejected() { - rejects_with( - Flavor::Default, - r#"effect Stash { + /// A body contradicting its own pinned row is rejected, naming the row. + a_body_contradicting_its_pinned_row_is_rejected: rejects_with(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() -> Unit !Stash = perform Stash.put("text") @@ -309,17 +228,10 @@ fn main() -> Unit = { put v => print("stored") in store() print("${done}") -}"#, - "outside its declared row", - ); -} +}"#, "outside its declared row"); -/// "A bare generic entry leaves its arguments to inference." -#[test] -fn a_bare_generic_row_entry_leaves_its_arguments_to_inference() { - accepts( - Flavor::Default, - r#"effect Stash { + /// "A bare generic entry leaves its arguments to inference." + a_bare_generic_row_entry_leaves_its_arguments_to_inference: accepts(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() -> Unit !Stash = perform Stash.put(42) @@ -328,17 +240,11 @@ fn main() -> Unit = { put v => print("stored ${v}") in store() print("${done}") -}"#, - ); -} +}"#); -/// A bracketed row may carry SEVERAL generic entries, each at its own -/// instantiation ([EFFECTS-GENERIC-ROWS], `effectSet`). -#[test] -fn a_bracketed_row_carries_several_generic_entries() { - accepts( - Flavor::Default, - r#"effect Read { + /// A bracketed row may carry SEVERAL generic entries, each at its own + /// instantiation ([EFFECTS-GENERIC-ROWS], `effectSet`). + a_bracketed_row_carries_several_generic_entries: accepts(Default, r#"effect Read { get: fn() -> T } effect Write { @@ -346,114 +252,76 @@ effect Write { } fn copy() -> Unit ![Read, Write] = perform Write.put("${perform Read.get()}") fn main() -> Unit = { - let done = handle Read + let done = handle Read get => 7 - in handle Write + in handle Write put v => print("wrote ${v}") in copy() print("${done}") -}"#, - ); +}"#); } // --------------------------------------------------------------------------- // [EFFECTS-GENERIC-RUNTIME] — the checker-visible half of the erased ABI // --------------------------------------------------------------------------- -/// "Static discharge distinguishes resolved instantiations" — an undischarged -/// operation is named AT its instantiation at program entry, which is what the -/// runtime's mangled key (`Stash$string`) mirrors. -#[test] -fn an_unhandled_generic_operation_is_named_at_its_instantiation() { - rejects_with( - Flavor::Default, - r#"effect Stash { +spec_cases! { + /// "Static discharge distinguishes resolved instantiations" — an undischarged + /// operation is named AT its instantiation at program entry, which is what the + /// runtime's mangled key (`Stash$string`) mirrors. + an_unhandled_generic_operation_is_named_at_its_instantiation: rejects_with(Default, r#"effect Stash { put: fn(T) -> Unit } fn store() = perform Stash.put("text") -fn main() -> Unit = store()"#, - "Stash.put", - ); +fn main() -> Unit = store()"#, "Stash.put"); } // --------------------------------------------------------------------------- // [FLAVOR-ML-GENERICS] — the ML spellings of the same effect surface // --------------------------------------------------------------------------- -/// "Effects use the same binder form: `effect Stash T`." ML operation arrows -/// are effectful (`=>`), as the corpus writes them. -#[test] -fn ml_effect_binders_are_juxtaposed() { - accepts( - Flavor::Ml, - "effect Stash T\n take : Unit => T\nprint \"declared\"\n", - ); -} +spec_cases! { + /// "Effects use the same binder form: `effect Stash T`." ML operation arrows + /// are effectful (`=>`), as the corpus writes them. + ml_effect_binders_are_juxtaposed: accepts(Ml, "effect Stash T\n take : Unit => T\nprint \"declared\"\n"); -/// "Effect rows apply arguments with angles: `! Stash`." -#[test] -fn ml_rows_apply_arguments_with_angles() { - accepts( - Flavor::Ml, - "effect Stash T\n put : T => Unit\n\ + /// "Effect rows apply arguments with angles: `! Stash`." + ml_rows_apply_arguments_with_angles: accepts(Ml, "effect Stash T\n put : T => Unit\n\ store : Unit -> Unit ! Stash\n\ store () = perform Stash.put 42\n\ main () =\n\ \x20 done = handle Stash\n\ \x20 put v => print \"stored\"\n\ \x20 in store ()\n\ - \x20 print \"${done}\"\n", - ); -} + \x20 print \"${done}\"\n"); -/// A bracketed ML row carries several generic entries: `! [Read, Write]`. -#[test] -fn ml_a_bracketed_row_carries_several_generic_entries() { - accepts( - Flavor::Ml, - "effect Read T\n get : Unit => T\n\ + /// A bracketed ML row carries several generic entries: `! [Read, Write]`. + ml_a_bracketed_row_carries_several_generic_entries: accepts(Ml, "effect Read T\n get : Unit => T\n\ effect Write T\n put : T => Unit\n\ copy : Unit -> Unit ! [Read, Write]\n\ - copy () = perform Write.put \"${perform Read.get ()}\"\n", - ); -} + copy () = perform Write.put \"${perform Read.get ()}\"\n"); -/// The ML twin of the operation-position rule. -#[test] -fn ml_out_in_an_operation_parameter_is_rejected() { - rejects_with( - Flavor::Ml, - "effect Bad out T\n send : T => Unit\nprint \"declared\"\n", - &op_position_message("T", "out", "input", "send", "Bad"), - ); -} + /// The ML twin of the operation-position rule. + ml_out_in_an_operation_parameter_is_rejected: rejects_with(Ml, "effect Bad out T\n send : T => Unit\nprint \"declared\"\n", op_position_message("T", "out", "input", "send", "Bad")); -/// The ML twin of the written-instantiation rules. -#[test] -fn ml_a_written_instantiation_is_accepted_on_handle_and_perform() { - accepts( - Flavor::Ml, - "effect Stash T\n take : Unit => T\n\ + /// The ML twin of the written-instantiation rules. + ml_a_written_instantiation_is_accepted_on_handle_and_perform: accepts(Ml, "effect Stash T\n take : Unit => T\n\ main () =\n\ \x20 held = handle Stash\n\ \x20 take => 9\n\ \x20 in perform Stash.take ()\n\ - \x20 print \"${held}\"\n", - ); + \x20 print \"${held}\"\n"); } // --------------------------------------------------------------------------- // Spec-vs-language drift, stated as a test rather than left as prose // --------------------------------------------------------------------------- -/// [EFFECTS-GENERIC-INSTANTIATION]'s own example writes the handled body after -/// `do`, not `in`. The language accepts only `in` today; the rename is plan -/// 0027 phase 0. One of the two sources is stale, and this test says which. -#[test] -fn the_spec_writes_a_handled_body_after_do() { - accepts( - Flavor::Default, - r#"effect Stash { +spec_cases! { + /// [EFFECTS-GENERIC-INSTANTIATION]'s own example writes the handled body after + /// `do`, not `in`. The language accepts only `in` today; the rename is plan + /// 0027 phase 0. One of the two sources is stale, and this test says which. + the_spec_writes_a_handled_body_after_do: accepts(Default, r#"effect Stash { put: fn(T) -> Unit take: fn() -> T } @@ -461,6 +329,5 @@ let word = handle Stash put value => print(value) take => "ready" do perform Stash.take() -print(word)"#, - ); +print(word)"#); } diff --git a/crates/osprey-types/src/generics_apply_ml_tests.rs b/crates/osprey-types/src/generics_apply_ml_tests.rs index 541246ee..8f5f0f82 100644 --- a/crates/osprey-types/src/generics_apply_ml_tests.rs +++ b/crates/osprey-types/src/generics_apply_ml_tests.rs @@ -6,315 +6,166 @@ //! Default assertion in `generics_apply_tests.rs` has a twin here and the two //! flavors must agree down to the diagnostic sentence. -use crate::testutil::{accepts, fn_arity_message, rejected_somehow, rejects_with}; -use osprey_syntax::Flavor; +use crate::testutil::{fn_arity_message, spec_cases}; /// The ML twin of `IDENTITY`: the binder lives on the signature line. const ML_IDENTITY: &str = "identity : T -> T\nidentity x = x\n"; /// The ML twin of `PICK`. const ML_PICK: &str = "pick : (T, U) -> T\npick (first, second) = first\n"; -/// "Call-site type arguments attach to the callee name and precede the -/// juxtaposed argument: `identity 5`." -#[test] -fn ml_type_application_pins_a_binder() { - accepts( - Flavor::Ml, - &format!( +spec_cases! { + /// "Call-site type arguments attach to the callee name and precede the + /// juxtaposed argument: `identity 5`." + ml_type_application_pins_a_binder: accepts(Ml, format!( r#"{ML_IDENTITY}pinned = identity 5 print "${{pinned}}""# - ), - ); -} + )); -/// The ML twin of the no-parameter-position case. -#[test] -fn ml_type_application_pins_a_binder_no_argument_mentions() { - accepts( - Flavor::Ml, - r#"empty : Unit -> List + /// The ML twin of the no-parameter-position case. + ml_type_application_pins_a_binder_no_argument_mentions: accepts(Ml, r#"empty : Unit -> List empty () = [] held = empty () -print "${length held}""#, - ); -} +print "${length held}""#); -/// Parenthesised ML argument tuples take type arguments too. -#[test] -fn ml_type_application_binds_binders_positionally() { - accepts( - Flavor::Ml, - &format!( + /// Parenthesised ML argument tuples take type arguments too. + ml_type_application_binds_binders_positionally: accepts(Ml, format!( r#"{ML_PICK}kept = pick (1, "two") print "${{kept}}""# - ), - ); -} + )); -/// The swapped ML twin must be rejected. -#[test] -fn ml_swapped_type_arguments_are_rejected() { - rejects_with( - Flavor::Ml, - &format!( + /// The swapped ML twin must be rejected. + ml_swapped_type_arguments_are_rejected: rejects_with(Ml, format!( r#"{ML_PICK}kept = pick (1, "two") print "${{kept}}""# - ), - "cannot unify", - ); -} + ), "cannot unify"); -/// The arity contract lives in the shared core, so ML reports the same -/// sentence as Default ([FLAVOR-BOUNDARY]). -#[test] -fn ml_type_application_arity_is_checked() { - rejects_with( - Flavor::Ml, - &format!( + /// The arity contract lives in the shared core, so ML reports the same + /// sentence as Default ([FLAVOR-BOUNDARY]). + ml_type_application_arity_is_checked: rejects_with(Ml, format!( r#"{ML_IDENTITY}pinned = identity 5 print "${{pinned}}""# - ), - &fn_arity_message("identity", 1, 2), - ); -} + ), fn_arity_message("identity", 1, 2)); -/// "A binding without a signature cannot declare function type parameters" — -/// and so cannot be applied at a call site either. -#[test] -fn ml_a_binding_without_a_signature_takes_no_type_arguments() { - rejects_with( - Flavor::Ml, - r#"plain x = x + /// "A binding without a signature cannot declare function type parameters" — + /// and so cannot be applied at a call site either. + ml_a_binding_without_a_signature_takes_no_type_arguments: rejects_with(Ml, r#"plain x = x pinned = plain 5 -print "${pinned}""#, - &fn_arity_message("plain", 0, 1), - ); -} +print "${pinned}""#, fn_arity_message("plain", 0, 1)); -/// A nested ML type argument closes with `>>` here too. -#[test] -fn ml_a_type_argument_may_itself_be_generic() { - accepts( - Flavor::Ml, - &format!( + /// A nested ML type argument closes with `>>` here too. + ml_a_type_argument_may_itself_be_generic: accepts(Ml, format!( r#"{ML_IDENTITY}held = identity> [1, 2] print "${{length held}}""# - ), - ); -} + )); -/// The ML control: `<` stays comparison under layout juxtaposition. -#[test] -fn ml_a_comparison_is_not_type_application() { - accepts( - Flavor::Ml, - r#"lower (a, b) = a < b + /// The ML control: `<` stays comparison under layout juxtaposition. + ml_a_comparison_is_not_type_application: accepts(Ml, r#"lower (a, b) = a < b flag = lower (1, 2) -print "${toString flag}""#, - ); -} +print "${toString flag}""#); -/// The ML gap rule matches Default's: `identity 5` is not application. -#[test] -fn ml_a_gap_before_the_angle_is_not_type_application() { - rejected_somehow( - Flavor::Ml, - &format!( + /// The ML gap rule matches Default's: `identity 5` is not application. + ml_a_gap_before_the_angle_is_not_type_application: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = identity 5 print "${{pinned}}""# - ), - ); -} + )); -/// ML variance markers are declaration-site only, at the call site as well. -#[test] -fn ml_a_variance_marker_at_a_call_site_is_rejected() { - rejected_somehow( - Flavor::Ml, - &format!( + /// ML variance markers are declaration-site only, at the call site as well. + ml_a_variance_marker_at_a_call_site_is_rejected: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = identity 5 print "${{pinned}}""# - ), - ); -} + )); -/// Curry-by-default: the written arguments attach to the callee name, so a -/// curried application takes them exactly once, at the front. -#[test] -fn ml_type_application_survives_curried_application() { - accepts( - Flavor::Ml, - &format!( - r#"{ML_PICK}kept = pick 1 "two" -print "${{kept}}""# - ), - ); -} + /// Curry-by-default: the written arguments attach to the callee name, so a + /// curried application takes them exactly once, at the front. + ml_type_application_survives_curried_application: accepts(Ml, r#"pick : T -> U -> T +pick first second = first +kept = pick 1 "two" +print "${kept}""#); -/// The ML twin of the value-argument contradiction. -#[test] -fn ml_type_application_contradicting_the_value_argument_is_rejected() { - rejects_with( - Flavor::Ml, - &format!( + /// The ML twin of the value-argument contradiction. + ml_type_application_contradicting_the_value_argument_is_rejected: rejects_with(Ml, format!( r#"{ML_IDENTITY}pinned = identity "text" print "${{pinned}}""# - ), - "cannot unify int with string", - ); -} + ), "cannot unify int with string"); -/// The ML twin of the expected-type contradiction, pinned by a signature. -#[test] -fn ml_type_application_contradicting_the_expected_type_is_rejected() { - rejects_with( - Flavor::Ml, - &format!( + /// The ML twin of the expected-type contradiction, pinned by a signature. + ml_type_application_contradicting_the_expected_type_is_rejected: rejects_with(Ml, format!( r#"{ML_IDENTITY}pinned : string pinned = identity 5 print "${{pinned}}""# - ), - "cannot unify", - ); -} + ), "cannot unify"); -/// The ML twin of "too few type arguments". -#[test] -fn ml_too_few_type_arguments_are_rejected_by_count() { - rejects_with( - Flavor::Ml, - &format!( + /// The ML twin of "too few type arguments". + ml_too_few_type_arguments_are_rejected_by_count: rejects_with(Ml, format!( r#"{ML_PICK}kept = pick (1, "two") print "${{kept}}""# - ), - &fn_arity_message("pick", 2, 1), - ); -} + ), fn_arity_message("pick", 2, 1)); -/// The ML twin of the lambda rule: `\x => x` declares no binder. -#[test] -fn ml_a_lambda_binding_takes_no_type_arguments() { - rejects_with( - Flavor::Ml, - r#"f = \x => x + /// The ML twin of the lambda rule: `\x => x` declares no binder. + ml_a_lambda_binding_takes_no_type_arguments: rejects_with(Ml, r#"f = \x => x pinned = f 5 -print "${pinned}""#, - &fn_arity_message("f", 0, 1), - ); -} +print "${pinned}""#, fn_arity_message("f", 0, 1)); -/// A declared record is a type argument in ML too. -#[test] -fn ml_a_declared_record_may_be_a_type_argument() { - accepts( - Flavor::Ml, - &format!( + /// A declared record is a type argument in ML too. + ml_a_declared_record_may_be_a_type_argument: accepts(Ml, format!( r#"type Box T = value : T {ML_IDENTITY}held = identity> (Box(value = 7)) print "${{held.value}}""# - ), - ); -} + )); -/// A function type is a type argument in ML too. -#[test] -fn ml_a_function_type_may_be_a_type_argument() { - accepts( - Flavor::Ml, - &format!( + /// A function type is a type argument in ML too. + ml_a_function_type_may_be_a_type_argument: accepts(Ml, format!( r#"{ML_IDENTITY}double n = n * 2 ?: 0 f = identity<(int) -> int> double print "${{f 21}}""# - ), - ); -} + )); -/// Two written instantiations of one ML binding coexist. -#[test] -fn ml_two_written_instantiations_coexist() { - accepts( - Flavor::Ml, - &format!( + /// Two written instantiations of one ML binding coexist. + ml_two_written_instantiations_coexist: accepts(Ml, format!( r#"{ML_IDENTITY}n = identity 5 s = identity "os" print "${{n}} ${{s}}""# - ), - ); -} + )); -/// Written arguments do not excuse a wrong value argument: applying `Unit` -/// where `int` was pinned still fails. The layer that catches it is not pinned -/// — under curry-by-default this reads as either an arity or a unification -/// failure, and both are truthful rejections. -#[test] -fn ml_writing_type_arguments_does_not_excuse_the_value_argument() { - rejected_somehow( - Flavor::Ml, - &format!( + /// Written arguments do not excuse a wrong value argument: applying `Unit` + /// where `int` was pinned still fails. The layer that catches it is not pinned + /// — under curry-by-default this reads as either an arity or a unification + /// failure, and both are truthful rejections. + ml_writing_type_arguments_does_not_excuse_the_value_argument: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = identity () print "${{pinned}}""# - ), - ); -} + )); -/// A pipe target has no juxtaposed argument, so it is not an application site. -#[test] -fn ml_type_arguments_in_a_pipe_target_are_rejected() { - rejected_somehow( - Flavor::Ml, - &format!( + /// A pipe target has no juxtaposed argument, so it is not an application site. + ml_type_arguments_in_a_pipe_target_are_rejected: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = 5 |> identity print "${{pinned}}""# - ), - ); -} + )); -/// An undeclared type name is not a type argument. -#[test] -fn ml_an_undeclared_type_argument_is_rejected() { - rejected_somehow( - Flavor::Ml, - &format!( + /// An undeclared type name is not a type argument. + ml_an_undeclared_type_argument_is_rejected: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = identity 5 print "${{pinned}}""# - ), - ); -} + )); -/// An empty argument list is not a type list in ML either. -#[test] -fn ml_an_empty_type_argument_list_is_rejected() { - rejected_somehow( - Flavor::Ml, - &format!( + /// An empty argument list is not a type list in ML either. + ml_an_empty_type_argument_list_is_rejected: rejected_somehow(Ml, format!( r#"{ML_IDENTITY}pinned = identity<> 5 print "${{pinned}}""# - ), - ); -} + )); -/// Type application inside a lambda body and a match arm. -#[test] -fn ml_type_application_works_inside_lambdas_and_match_arms() { - accepts( - Flavor::Ml, - &format!( + /// Type application inside a lambda body and a match arm. + ml_type_application_works_inside_lambdas_and_match_arms: accepts(Ml, format!( r#"{ML_IDENTITY}wrap = \n => identity n chosen = match wrap 1 1 => identity "one" _ => identity "other" print "${{chosen}}""# - ), - ); -} + )); -/// Call-site application coexists with an inferred generic effect in ML too. -#[test] -fn ml_type_application_coexists_with_generic_effect_instantiation() { - accepts( - Flavor::Ml, - &format!( + /// Call-site application coexists with an inferred generic effect in ML too. + ml_type_application_coexists_with_generic_effect_instantiation: accepts(Ml, format!( r#"effect Stash T take : Unit => T {ML_IDENTITY}main () = @@ -322,6 +173,5 @@ fn ml_type_application_coexists_with_generic_effect_instantiation() { take => identity 9 in perform Stash.take () print "${{held}}""# - ), - ); + )); } diff --git a/crates/osprey-types/src/generics_apply_tests.rs b/crates/osprey-types/src/generics_apply_tests.rs index 6f0a7675..e9c04502 100644 --- a/crates/osprey-types/src/generics_apply_tests.rs +++ b/crates/osprey-types/src/generics_apply_tests.rs @@ -4,258 +4,139 @@ //! //! Type arguments have three positions in the language: the declaration binder //! (`fn pick`), the construction site (`Box { … }`) and the call -//! site. The first two land; this module states the third, which is the only -//! spelling that can pin a binder appearing in no parameter position — an -//! annotated `let` pins a *return*, never a binder the arguments never mention. +//! site. Written arguments pin binders directly, including when value +//! arguments provide no constraint. An expected result type can also pin a +//! binder appearing in the return; an unconstrained immutable binding generalizes. //! Tracked by plan 0015. //! //! Each test states one spec sentence and drives the compiler's public surface //! — parse, then check — so a snippet the PARSER rejects is reported as a //! syntax failure instead of being mistaken for a checker rejection. -use crate::testutil::{accepts, fn_arity_message, rejected_somehow, rejects_with}; -use osprey_syntax::Flavor; +use crate::testutil::{fn_arity_message, spec_cases}; /// `fn identity` — one binder, mentioned by the parameter and the return. const IDENTITY: &str = "fn identity(x: T) -> T = x\n"; /// `fn pick` — two binders, so written ORDER is observable. const PICK: &str = "fn pick(first: T, second: U) -> T = first\n"; -/// A binder in NO parameter position: inference alone can never pin it. +/// A binder absent from parameters: written arguments or result context can pin it. const EMPTY: &str = "fn empty() -> List = []\n"; // --------------------------------------------------------------------------- // The accepted form — Default flavor // --------------------------------------------------------------------------- -/// "`identity(5)` pins the callee's declared binders positionally." -#[test] -fn type_application_pins_a_binder_at_a_call_site() { - accepts( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), - ); -} +spec_cases! { + /// "`identity(5)` pins the callee's declared binders positionally." + type_application_pins_a_binder_at_a_call_site: accepts(Default, format!(r#"{IDENTITY}print("${{identity(5)}}")"#)); -/// "the only spelling that can pin a binder appearing in no parameter -/// position" — nothing else in this program mentions `T`. -#[test] -fn type_application_pins_a_binder_no_argument_mentions() { - accepts( - Flavor::Default, - &format!(r#"{EMPTY}print("${{length(empty())}}")"#), - ); -} + /// Written arguments pin a binder absent from parameters when nothing else + /// in the program constrains it. + type_application_pins_a_binder_no_argument_mentions: accepts(Default, format!(r#"{EMPTY}print("${{length(empty())}}")"#)); -/// The same call WITHOUT the written argument leaves the binder unresolved, so -/// the accepted case above cannot be passing for an unrelated reason. -#[test] -fn the_unpinnable_binder_is_the_control_for_that_case() { - rejected_somehow( - Flavor::Default, - &format!( + /// An immutable binding generalizes an unpinned element type. Reading the + /// list's length does not require a concrete element instantiation. + an_unpinned_binder_generalizes_at_an_immutable_binding: accepts(Default, format!( r#"{EMPTY}let held = empty() print("${{length(held)}}")"# - ), - ); -} + )); -/// "the written arguments unify with the instantiation the value arguments and -/// the expected type would otherwise infer" — agreement is accepted. -#[test] -fn type_application_agreeing_with_the_value_argument_is_accepted() { - accepts( - Flavor::Default, - &format!( + /// "the written arguments unify with the instantiation the value arguments and + /// the expected type would otherwise infer" — agreement is accepted. + type_application_agreeing_with_the_value_argument_is_accepted: accepts(Default, format!( r#"{IDENTITY}let n: int = identity(5) print("${{n}}")"# - ), - ); -} + )); -/// Binders are pinned LEFT TO RIGHT. -#[test] -fn type_application_binds_binders_positionally() { - accepts( - Flavor::Default, - &format!( + /// Binders are pinned LEFT TO RIGHT. + type_application_binds_binders_positionally: accepts(Default, format!( r#"{PICK}let kept = pick(1, "two") print("${{kept}}")"# - ), - ); -} + )); -/// The swapped twin of the case above must NOT type-check. -#[test] -fn swapped_type_arguments_are_rejected() { - rejects_with( - Flavor::Default, - &format!( + /// The swapped twin of the case above must NOT type-check. + swapped_type_arguments_are_rejected: rejects_with(Default, format!( r#"{PICK}let kept = pick(1, "two") print("${{kept}}")"# - ), - "cannot unify", - ); -} + ), "cannot unify"); -/// A type argument may itself be generic: the `>>` closing two argument lists -/// must lex as two closers, not as one shift operator. -#[test] -fn a_type_argument_may_itself_be_generic() { - accepts( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{length(identity>([1, 2]))}}")"#), - ); -} + /// A type argument may itself be generic: the `>>` closing two argument lists + /// must lex as two closers, not as one shift operator. + a_type_argument_may_itself_be_generic: accepts(Default, format!(r#"{IDENTITY}print("${{length(identity>([1, 2]))}}")"#)); -/// Three closers in a row (`>>>`), and a two-argument constructor inside. -#[test] -fn a_type_argument_may_nest_two_levels_deep() { - accepts( - Flavor::Default, - &format!( + /// Three closers in a row (`>>>`), and a two-argument constructor inside. + a_type_argument_may_nest_two_levels_deep: accepts(Default, format!( r#"{IDENTITY}let groups = identity>>({{"a": [1]}}) print("${{mapLength(groups)}}")"# - ), - ); -} + )); -/// A declared record is as good a type argument as a primitive. -#[test] -fn a_declared_record_may_be_a_type_argument() { - accepts( - Flavor::Default, - &format!( + /// A declared record is as good a type argument as a primitive. + a_declared_record_may_be_a_type_argument: accepts(Default, format!( r#"type Box = {{ value: T }} {IDENTITY}let boxed = identity>(Box {{ value: 7 }}) print("${{boxed.value}}")"# - ), - ); -} + )); -/// A function type is a type, so it may be written as a type argument. -#[test] -fn a_function_type_may_be_a_type_argument() { - accepts( - Flavor::Default, - &format!( + /// A function type is a type, so it may be written as a type argument. + a_function_type_may_be_a_type_argument: accepts(Default, format!( r#"{IDENTITY}fn double(n) = n * 2 ?: 0 let f = identity<(int) -> int>(double) print("${{f(21)}}")"# - ), - ); -} + )); -/// `Result` is a type argument like any other — and writing it does NOT -/// unwrap the failure channel ([TYPE-VARIANCE-ASSIGN]). -#[test] -fn a_result_type_may_be_a_type_argument() { - accepts( - Flavor::Default, - &format!( + /// `Result` is a type argument like any other — and writing it does NOT + /// unwrap the failure channel ([TYPE-VARIANCE-ASSIGN]). + a_result_type_may_be_a_type_argument: accepts(Default, format!( r#"{IDENTITY}let quotient = identity>(20 * 5) print("${{quotient ?: 0}}")"# - ), - ); -} + )); -/// Type application is an expression: it nests inside another call. -#[test] -fn type_application_nests_inside_another_call() { - accepts( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(identity(5))}}")"#), - ); -} + /// Type application is an expression: it nests inside another call. + type_application_nests_inside_another_call: accepts(Default, format!(r#"{IDENTITY}print("${{identity(identity(5))}}")"#)); -/// Two written instantiations of ONE binding coexist — monomorphisation is -/// per call site ([TYPE-GENERICS-FN]). -#[test] -fn two_written_instantiations_coexist_in_one_program() { - accepts( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#), - ); -} + /// Two written instantiations of ONE binding coexist — monomorphisation is + /// per call site ([TYPE-GENERICS-FN]). + two_written_instantiations_coexist_in_one_program: accepts(Default, format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#)); -/// Named arguments are orthogonal to type arguments. -#[test] -fn type_application_composes_with_named_arguments() { - accepts( - Flavor::Default, - &format!( + /// Named arguments are orthogonal to type arguments. + type_application_composes_with_named_arguments: accepts(Default, format!( r#"{PICK}let kept = pick(first: 1, second: "two") print("${{kept}}")"# - ), - ); -} + )); -/// Receiver-first (UFCS) dispatch keeps the type arguments on the member name. -#[test] -fn type_application_composes_with_receiver_first_dispatch() { - accepts( - Flavor::Default, - &format!( - r#"fn headOr(items: List, fallback: T) -> T = items.listGet(0) ?: fallback + /// Receiver-first (UFCS) dispatch keeps the type arguments on the member name. + type_application_composes_with_receiver_first_dispatch: accepts(Default, r#"fn headOr(items: List, fallback: T) -> T = items.listGet(0) ?: fallback let first = [1, 2].headOr(0) -print("${{first}}")"# - ), - ); -} +print("${first}")"#); -/// A generic HOF's binder may be pinned while the callback stays inferred. -#[test] -fn type_application_pins_a_generic_higher_order_call() { - accepts( - Flavor::Default, - &format!( - r#"fn also(x: T, f: (T) -> T) -> T = f(x) + /// A generic HOF's binder may be pinned while the callback stays inferred. + type_application_pins_a_generic_higher_order_call: accepts(Default, r#"fn also(x: T, f: (T) -> T) -> T = f(x) fn double(n) = n * 2 ?: 0 -print("${{also(21, double)}}")"# - ), - ); -} +print("${also(21, double)}")"#); -/// The binder in scope may be applied to a RECURSIVE call inside the generic -/// function's own body. -#[test] -fn a_binder_in_scope_may_be_applied_recursively() { - accepts( - Flavor::Default, - &format!( - r#"fn repeatOf(value: T, times: int) -> T = match times {{ + /// The binder in scope may be applied to a RECURSIVE call inside the generic + /// function's own body. + a_binder_in_scope_may_be_applied_recursively: accepts(Default, r#"fn repeatOf(value: T, times: int) -> T = match times { 0 => value _ => repeatOf(value, times - 1 ?: 0) -}} -print("${{repeatOf(7, 3)}}")"# - ), - ); } +print("${repeatOf(7, 3)}")"#); -/// Inside a lambda body, and inside a match arm — no statement-level special -/// case. -#[test] -fn type_application_works_inside_lambdas_and_match_arms() { - accepts( - Flavor::Default, - &format!( + /// Inside a lambda body, and inside a match arm — no statement-level special + /// case. + type_application_works_inside_lambdas_and_match_arms: accepts(Default, format!( r#"{IDENTITY}let wrap = |n| => identity(n) let chosen = match wrap(1) {{ 1 => identity("one") _ => identity("other") }} print("${{chosen}}")"# - ), - ); -} + )); -/// Call-site application coexists with a generic effect whose instantiation is -/// INFERRED — a written one is rejected on a dynamic effect ([STAGE-SIGNALS-EXACT]), -/// so the `<` after a callee name must not be read as an effect mention. -#[test] -fn type_application_coexists_with_generic_effect_instantiation() { - accepts( - Flavor::Default, - &format!( + /// Call-site application coexists with a generic effect whose instantiation is + /// INFERRED — a written one is rejected on a dynamic effect ([STAGE-SIGNALS-EXACT]), + /// so the `<` after a callee name must not be read as an effect mention. + type_application_coexists_with_generic_effect_instantiation: accepts(Default, format!( r#"effect Stash {{ take: fn() -> T }} @@ -265,210 +146,97 @@ fn type_application_coexists_with_generic_effect_instantiation() { in perform Stash.take() print("${{held}}") }}"# - ), - ); + )); } // --------------------------------------------------------------------------- // The rejections // --------------------------------------------------------------------------- -/// "A written argument that contradicts the value arguments … is a type error, -/// not a silently ignored annotation." -#[test] -fn type_application_contradicting_the_value_argument_is_rejected() { - rejects_with( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity("text")}}")"#), - "cannot unify int with string", - ); -} +spec_cases! { + /// "A written argument that contradicts the value arguments … is a type error, + /// not a silently ignored annotation." + type_application_contradicting_the_value_argument_is_rejected: rejects_with(Default, format!(r#"{IDENTITY}print("${{identity("text")}}")"#), "cannot unify int with string"); -/// A contradiction against the EXPECTED type is caught the same way, even -/// though the value argument agrees with what was written. -#[test] -fn type_application_contradicting_the_expected_type_is_rejected() { - rejects_with( - Flavor::Default, - &format!( - r#"{IDENTITY}let s: string = identity(5) -print(s)"# - ), - "cannot unify", - ); -} + /// A contradiction against the EXPECTED type is caught the same way, even + /// though the value argument agrees with what was written. + type_application_contradicting_the_expected_type_is_rejected: rejects_with(Default, format!( + r"{IDENTITY}let s: string = identity(5) +print(s)" + ), "cannot unify"); -/// A contradiction one level down: the written `List` disagrees with a -/// `List` value. -#[test] -fn a_nested_type_argument_contradiction_is_rejected() { - rejects_with( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{length(identity>(["a"]))}}")"#), - "cannot unify", - ); -} + /// A contradiction one level down: the written `List` disagrees with a + /// `List` value. + a_nested_type_argument_contradiction_is_rejected: rejects_with(Default, format!(r#"{IDENTITY}print("${{length(identity>(["a"]))}}")"#), "cannot unify"); -/// "The count must equal the callee's declared binder count." -#[test] -fn too_many_type_arguments_are_rejected_by_count() { - rejects_with( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), - &fn_arity_message("identity", 1, 2), - ); -} + /// "The count must equal the callee's declared binder count." + too_many_type_arguments_are_rejected_by_count: rejects_with(Default, format!(r#"{IDENTITY}print("${{identity(5)}}")"#), fn_arity_message("identity", 1, 2)); -/// The same rule in the other direction: two binders, one written argument. -#[test] -fn too_few_type_arguments_are_rejected_by_count() { - rejects_with( - Flavor::Default, - &format!( + /// The same rule in the other direction: two binders, one written argument. + too_few_type_arguments_are_rejected_by_count: rejects_with(Default, format!( r#"{PICK}let kept = pick(1, "two") print("${{kept}}")"# - ), - &fn_arity_message("pick", 2, 1), - ); -} + ), fn_arity_message("pick", 2, 1)); -/// "A callee that declares no binders … takes no type arguments." An -/// unannotated function is implicitly polymorphic, which is NOT a binder. -#[test] -fn a_function_without_a_binder_takes_no_type_arguments() { - rejects_with( - Flavor::Default, - r#"fn plain(x) = x -print("${plain(5)}")"#, - &fn_arity_message("plain", 0, 1), - ); -} + /// "A callee that declares no binders … takes no type arguments." An + /// unannotated function is implicitly polymorphic, which is NOT a binder. + a_function_without_a_binder_takes_no_type_arguments: rejects_with(Default, r#"fn plain(x) = x +print("${plain(5)}")"#, fn_arity_message("plain", 0, 1)); -/// A lambda binding declares no binders either. -#[test] -fn a_lambda_binding_takes_no_type_arguments() { - rejects_with( - Flavor::Default, - r#"let f = |x| => x -print("${f(5)}")"#, - &fn_arity_message("f", 0, 1), - ); -} + /// A lambda binding declares no binders either. + a_lambda_binding_takes_no_type_arguments: rejects_with(Default, r#"let f = |x| => x +print("${f(5)}")"#, fn_arity_message("f", 0, 1)); -/// A parameter holding a function value declares no binders. -#[test] -fn a_function_valued_parameter_takes_no_type_arguments() { - rejects_with( - Flavor::Default, - r#"fn apply(f, x) = f(x) -print("${apply(|n| => n, 5)}")"#, - &fn_arity_message("f", 0, 1), - ); -} + /// A parameter holding a function value declares no binders. + a_function_valued_parameter_takes_no_type_arguments: rejects_with(Default, r#"fn apply(f, x) = f(x) +print("${apply(|n| => n, 5)}")"#, fn_arity_message("f", 0, 1)); -/// Value arity is still checked when type arguments are written: the two -/// argument lists are independent contracts. -#[test] -fn writing_type_arguments_does_not_excuse_a_missing_value_argument() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity()}}")"#), - ); -} + /// Value arity is still checked when type arguments are written: the two + /// argument lists are independent contracts. + writing_type_arguments_does_not_excuse_a_missing_value_argument: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity()}}")"#)); -/// "Variance markers are not permitted, exactly as on the binder itself." -#[test] -fn a_covariance_marker_at_a_call_site_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), - ); -} + /// "Variance markers are not permitted, exactly as on the binder itself." + a_covariance_marker_at_a_call_site_is_rejected: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity(5)}}")"#)); -/// The contravariant half of the same rule. -#[test] -fn a_contravariance_marker_at_a_call_site_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), - ); -} + /// The contravariant half of the same rule. + a_contravariance_marker_at_a_call_site_is_rejected: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity(5)}}")"#)); -/// A type argument names a TYPE. An undeclared name is not one. -#[test] -fn an_undeclared_type_argument_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}}")"#), - ); -} + /// A type argument names a TYPE. An undeclared name is not one. + an_undeclared_type_argument_is_rejected: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity(5)}}")"#)); -/// An empty argument list is not a type list. -#[test] -fn an_empty_type_argument_list_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity<>(5)}}")"#), - ); -} + /// An empty argument list is not a type list. + an_empty_type_argument_list_is_rejected: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity<>(5)}}")"#)); -/// "the matching `>` immediately precedes the call's argument list" — with no -/// argument list there is no type application, so a bare `identity` value -/// is not the way to specialise a function value. -#[test] -fn type_arguments_without_an_argument_list_are_rejected() { - rejected_somehow( - Flavor::Default, - &format!( + /// "the matching `>` immediately precedes the call's argument list" — with no + /// argument list there is no type application, so a bare `identity` value + /// is not the way to specialise a function value. + type_arguments_without_an_argument_list_are_rejected: rejected_somehow(Default, format!( r#"{IDENTITY}let g = identity print("${{g(5)}}")"# - ), - ); -} + )); -/// "recognised when the `<` immediately follows the callee name" — a gap makes -/// it the comparison operator again, and `identity (5)` is then nonsense. -#[test] -fn a_gap_before_the_angle_is_not_type_application() { - rejected_somehow( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity (5)}}")"#), - ); + /// "recognised when the `<` immediately follows the callee name" — a gap makes + /// it the comparison operator again, and `identity (5)` is then nonsense. + a_gap_before_the_angle_is_not_type_application: rejected_somehow(Default, format!(r#"{IDENTITY}print("${{identity (5)}}")"#)); } // --------------------------------------------------------------------------- // Positive controls — `<` stays the comparison operator everywhere else // --------------------------------------------------------------------------- -/// "Everywhere else `<` is the comparison operator, so `a < b` and -/// `f(a) < g(b)` are unaffected." Green today; must stay green after. -#[test] -fn a_comparison_is_not_type_application() { - accepts( - Flavor::Default, - &format!( +spec_cases! { + /// "Everywhere else `<` is the comparison operator, so `a < b` and + /// `f(a) < g(b)` are unaffected." Green today; must stay green after. + a_comparison_is_not_type_application: accepts(Default, format!( r#"{IDENTITY}fn lower(a, b) = a < b print("${{toString(lower(1, 2))}} ${{toString(identity(3) < identity(4))}}")"# - ), - ); -} + )); -/// A parenthesised relational chain keeps working ("must parenthesise"). -#[test] -fn a_parenthesised_relational_chain_still_checks() { - accepts( - Flavor::Default, - r#"let flag = (1 < 2) == true -print("${toString(flag)}")"#, - ); -} + /// A parenthesised relational chain keeps working ("must parenthesise"). + a_parenthesised_relational_chain_still_checks: accepts(Default, r#"let flag = (1 < 2) == true +print("${toString(flag)}")"#); -/// Inference without written arguments is untouched: one binder still serves -/// two instantiations ([TYPE-GENERICS-FN]). -#[test] -fn omitting_type_arguments_still_infers_each_instantiation() { - accepts( - Flavor::Default, - &format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#), - ); + /// Inference without written arguments is untouched: one binder still serves + /// two instantiations ([TYPE-GENERICS-FN]). + omitting_type_arguments_still_infers_each_instantiation: accepts(Default, format!(r#"{IDENTITY}print("${{identity(5)}} ${{identity("os")}}")"#)); } diff --git a/crates/osprey-types/src/generics_decl_tests.rs b/crates/osprey-types/src/generics_decl_tests.rs index f7cd8c5b..4a9f03a2 100644 --- a/crates/osprey-types/src/generics_decl_tests.rs +++ b/crates/osprey-types/src/generics_decl_tests.rs @@ -7,7 +7,7 @@ //! covers the two positions that already ship, and the permutations of each //! sentence the spec writes about them. -use crate::testutil::{accepts, ctor_arity_message, rejected_somehow, rejects_with}; +use crate::testutil::{accepts, ctor_arity_message, rejects_with, spec_cases}; use osprey_syntax::Flavor; /// One binder, one field. @@ -19,138 +19,76 @@ const PAIR: &str = "type Pair = { first: T, second: U }\n"; // [TYPE-GENERICS-DECL] — binders span every variant field // --------------------------------------------------------------------------- -/// "`type Pair = …` binds `T`/`U` across every variant field." -#[test] -fn a_binder_spans_every_variant_field() { - accepts( - Flavor::Default, - r#"type Holder = Full { left: T, right: U } | Half { only: T } | None +spec_cases! { + /// "`type Pair = …` binds `T`/`U` across every variant field." + a_binder_spans_every_variant_field: accepts(Default, r#"type Holder = Full { left: T, right: U } | Half { only: T } | None fn label(h: Holder) = match h { Full { left, right } => right Half { only } => "half" None => "none" } -print(label(Full { left: 1, right: "one" }))"#, - ); -} +print(label(Full { left: 1, right: "one" }))"#); -/// One binder used twice in one variant pins both fields to one type. -#[test] -fn one_binder_used_twice_pins_both_fields() { - rejects_with( - Flavor::Default, - r#"type Both = { left: T, right: T } + /// One binder used twice in one variant pins both fields to one type. + one_binder_used_twice_pins_both_fields: rejects_with(Default, r#"type Both = { left: T, right: T } let b = Both { left: 1, right: "two" } -print("${b.left}")"#, - "cannot unify", - ); -} +print("${b.left}")"#, "cannot unify"); -/// "A construction site may apply explicit type arguments … which unify with -/// the instantiation the fields would otherwise infer." -#[test] -fn a_construction_site_may_pin_its_instantiation() { - accepts( - Flavor::Default, - &format!( + /// "A construction site may apply explicit type arguments … which unify with + /// the instantiation the fields would otherwise infer." + a_construction_site_may_pin_its_instantiation: accepts(Default, format!( r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} print("${{p.first}}${{p.second}}")"# - ), - ); -} + )); -/// "an argument that contradicts a field is a type error." -#[test] -fn a_construction_type_argument_contradicting_a_field_is_rejected() { - rejects_with( - Flavor::Default, - &format!( + /// "an argument that contradicts a field is a type error." + a_construction_type_argument_contradicting_a_field_is_rejected: rejects_with(Default, format!( r#"{BOX}let b = Box {{ value: "text" }} print("${{b.value}}")"# - ), - "cannot unify", - ); -} + ), "cannot unify"); -/// The contradiction is caught in the second position as well. -#[test] -fn a_contradiction_in_the_second_type_argument_is_rejected() { - rejects_with( - Flavor::Default, - &format!( + /// The contradiction is caught in the second position as well. + a_contradiction_in_the_second_type_argument_is_rejected: rejects_with(Default, format!( r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} print("${{p.first}}")"# - ), - "cannot unify", - ); -} + ), "cannot unify"); -/// A nested instantiation is pinned the same way. -#[test] -fn a_nested_construction_type_argument_is_checked() { - accepts( - Flavor::Default, - &format!( + /// A nested instantiation is pinned the same way. + a_nested_construction_type_argument_is_checked: accepts(Default, format!( r#"{BOX}let nested = Box> {{ value: Box {{ value: 7 }} }} print("${{nested.value.value}}")"# - ), - ); + )); } // --------------------------------------------------------------------------- // [GENERICS-CTOR-ARITY] — the count is a contract with the declaration // --------------------------------------------------------------------------- -/// "`Box { v: 1 }` is rejected with `takes 1 type argument(s), got 2`." -#[test] -fn too_many_construction_type_arguments_are_rejected() { - rejects_with( - Flavor::Default, - &format!( +spec_cases! { + /// "`Box { v: 1 }` is rejected with `takes 1 type argument(s), got 2`." + too_many_construction_type_arguments_are_rejected: rejects_with(Default, format!( r#"{BOX}let b = Box {{ value: 1 }} print("${{b.value}}")"# - ), - &ctor_arity_message("Box", 1, 2), - ); -} + ), ctor_arity_message("Box", 1, 2)); -/// The other direction: two binders, one written argument. -#[test] -fn too_few_construction_type_arguments_are_rejected() { - rejects_with( - Flavor::Default, - &format!( + /// The other direction: two binders, one written argument. + too_few_construction_type_arguments_are_rejected: rejects_with(Default, format!( r#"{PAIR}let p = Pair {{ first: 1, second: "a" }} print("${{p.first}}")"# - ), - &ctor_arity_message("Pair", 2, 1), - ); -} + ), ctor_arity_message("Pair", 2, 1)); -/// A type that declares NO binders accepts no type arguments. -#[test] -fn a_non_generic_type_takes_no_construction_type_arguments() { - rejects_with( - Flavor::Default, - r#"type Plain = { value: int } + /// A type that declares NO binders accepts no type arguments. + a_non_generic_type_takes_no_construction_type_arguments: rejects_with(Default, r#"type Plain = { value: int } let p = Plain { value: 1 } -print("${p.value}")"#, - &ctor_arity_message("Plain", 0, 1), - ); -} +print("${p.value}")"#, ctor_arity_message("Plain", 0, 1)); -/// Omitting the arguments entirely stays legal — they are optional, and -/// inference supplies them. -#[test] -fn omitting_construction_type_arguments_still_infers() { - accepts( - Flavor::Default, - &format!( + /// Omitting the arguments entirely stays legal — they are optional, and + /// inference supplies them. + omitting_construction_type_arguments_still_infers: accepts(Default, format!( r#"{BOX}let n = Box {{ value: 1 }} let s = Box {{ value: "one" }} print("${{n.value}}${{s.value}}")"# - ), - ); + )); } // --------------------------------------------------------------------------- @@ -174,15 +112,11 @@ print("${pick(10, "twenty")}")"#, ); } -/// "without it, `T` in an annotation names a nominal type" — an undeclared -/// nominal name is not a type. -#[test] -fn an_unbound_annotation_name_is_nominal_not_a_binder() { - rejected_somehow( - Flavor::Default, - r#"fn nom(a: T) -> T = a -print("${nom(1)}")"#, - ); +spec_cases! { + /// "without it, `T` in an annotation names a nominal type" — an undeclared + /// nominal name is not a type. + an_unbound_annotation_name_is_nominal_not_a_binder: rejected_somehow(Default, r#"fn nom(a: T) -> T = a +print("${nom(1)}")"#); } /// …and when that nominal name IS declared, it binds nothing: the function is @@ -204,178 +138,85 @@ print("${nom(1)}")"#, ); } -/// "HM inference is unchanged: unannotated functions stay implicitly -/// polymorphic." -#[test] -fn an_unannotated_function_stays_implicitly_polymorphic() { - accepts( - Flavor::Default, - r#"fn id(x) = x -print("${id(5)} ${id("os")} ${toString(id(true))}")"#, - ); -} +spec_cases! { + /// "HM inference is unchanged: unannotated functions stay implicitly + /// polymorphic." + an_unannotated_function_stays_implicitly_polymorphic: accepts(Default, r#"fn id(x) = x +print("${id(5)} ${id("os")} ${toString(id(true))}")"#); -/// Two binders are independent: they may be instantiated at the same type or -/// at different ones. -#[test] -fn two_binders_are_independent() { - accepts( - Flavor::Default, - r#"fn pair(first: T, second: U) -> T = first -print("${pair(1, "a")} ${pair(1, 2)}")"#, - ); -} + /// Two binders are independent: they may be instantiated at the same type or + /// at different ones. + two_binders_are_independent: accepts(Default, r#"fn pair(first: T, second: U) -> T = first +print("${pair(1, "a")} ${pair(1, 2)}")"#); -/// A binder list names DISTINCT parameters; a repeat has no meaning. -#[test] -fn a_repeated_binder_name_is_rejected() { - rejected_somehow( - Flavor::Default, - r#"fn dup(first: T, second: T) -> T = first -print("${dup(1, 2)}")"#, - ); -} + /// A binder list names DISTINCT parameters; a repeat has no meaning. + a_repeated_binder_name_is_rejected: rejected_somehow(Default, r#"fn dup(first: T, second: T) -> T = first +print("${dup(1, 2)}")"#); -/// An empty binder list is not a binder list. -#[test] -fn an_empty_binder_list_is_rejected() { - rejected_somehow( - Flavor::Default, - r#"fn none<>(x) = x -print("${none(1)}")"#, - ); -} + /// An empty binder list is not a binder list. + an_empty_binder_list_is_rejected: rejected_somehow(Default, r#"fn none<>(x) = x +print("${none(1)}")"#); -/// A binder may appear in the return position only — the shape call-site type -/// application exists to serve ([TYPE-GENERICS-APPLY]). -#[test] -fn a_binder_may_appear_in_the_return_position_only() { - accepts( - Flavor::Default, - r#"fn empty() -> List = [] + /// A binder may appear in the return position only — the shape call-site type + /// application exists to serve ([TYPE-GENERICS-APPLY]). + a_binder_may_appear_in_the_return_position_only: accepts(Default, r#"fn empty() -> List = [] let held: List = empty() -print("${length(held)}")"#, - ); +print("${length(held)}")"#); } // --------------------------------------------------------------------------- // [TYPE-GENERICS-FN] — a generic function as a VALUE // --------------------------------------------------------------------------- -/// "specialised wherever its ABI can be fixed: by a consuming slot, by a call -/// alias" — the alias form. -#[test] -fn a_generic_function_binds_as_a_call_alias() { - accepts( - Flavor::Default, - r#"fn identity(x: T) -> T = x +spec_cases! { + /// "specialised wherever its ABI can be fixed: by a consuming slot, by a call + /// alias" — the alias form. + a_generic_function_binds_as_a_call_alias: accepts(Default, r#"fn identity(x: T) -> T = x let g = identity -print("${g(5)} ${g("os")}")"#, - ); -} +print("${g(5)} ${g("os")}")"#); -/// …and the consuming-slot form: a generic function passed by name to a HOF. -#[test] -fn a_generic_function_specialises_into_a_consuming_slot() { - accepts( - Flavor::Default, - r#"fn identity(x: T) -> T = x + /// …and the consuming-slot form: a generic function passed by name to a HOF. + a_generic_function_specialises_into_a_consuming_slot: accepts(Default, r#"fn identity(x: T) -> T = x fn also(x, f) = f(x) -print("${also(5, identity)} ${also("os", identity)}")"#, - ); -} +print("${also(5, identity)} ${also("os", identity)}")"#); -/// "`fn pick() = |x| => x` followed by `let f = pick()` therefore serves -/// `f(7)`, `f("os")` and `f(2.5)` from one binding." -#[test] -fn a_returned_generic_lambda_serves_every_call_site_of_its_binding() { - accepts( - Flavor::Default, - r#"fn mk() = |x| => x + /// "`fn pick() = |x| => x` followed by `let f = pick()` therefore serves + /// `f(7)`, `f("os")` and `f(2.5)` from one binding." + a_returned_generic_lambda_serves_every_call_site_of_its_binding: accepts(Default, r#"fn mk() = |x| => x let f = mk() -print("${f(7)} ${f("os")} ${f(2.5)}")"#, - ); -} +print("${f(7)} ${f("os")} ${f(2.5)}")"#); -/// "A lambda so returned may close over the producing call's parameters." -#[test] -fn a_returned_lambda_may_close_over_the_producing_call() { - accepts( - Flavor::Default, - r#"fn constly(v) = |x| => v + /// "A lambda so returned may close over the producing call's parameters." + a_returned_lambda_may_close_over_the_producing_call: accepts(Default, r#"fn constly(v) = |x| => v let always = constly(9) -print("${always(1)} ${always("os")}")"#, - ); -} +print("${always(1)} ${always("os")}")"#); -/// "a still-generic lambda used as a bare value … is rejected rather than -/// guessed", with the compiler's own sentence. -#[test] -fn a_still_generic_lambda_as_a_bare_value_is_rejected() { - rejects_with( - Flavor::Default, - r#"fn mk(x) = |y| => x -print("${mk(1)}")"#, - "a closure value with a still-generic type", - ); + /// "a still-generic lambda used as a bare value … is rejected rather than + /// guessed", with the compiler's own sentence. + a_still_generic_lambda_as_a_bare_value_is_rejected: rejects_with(Default, r#"fn mk(x) = |y| => x +print("${mk(1)}")"#, "a closure value with a still-generic type"); } // --------------------------------------------------------------------------- // [FLAVOR-ML-GENERICS] — the ML spellings of the same declarations // --------------------------------------------------------------------------- -/// "Types use juxtaposed binders: `type Box T`." -#[test] -fn ml_type_binders_are_juxtaposed() { - accepts( - Flavor::Ml, - "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", - ); -} +spec_cases! { + /// "Types use juxtaposed binders: `type Box T`." + ml_type_binders_are_juxtaposed: accepts(Ml, "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n"); -/// "Construction-site type arguments use `Box(item = 7)`." -#[test] -fn ml_construction_type_arguments_use_angles() { - accepts( - Flavor::Ml, - "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", - ); -} + /// "Construction-site type arguments use `Box(item = 7)`." + ml_construction_type_arguments_use_angles: accepts(Ml, "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n"); -/// The ML construction site is held to the same arity contract. -#[test] -fn ml_construction_type_argument_arity_is_checked() { - rejects_with( - Flavor::Ml, - "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", - &ctor_arity_message("Box", 1, 2), - ); -} + /// The ML construction site is held to the same arity contract. + ml_construction_type_argument_arity_is_checked: rejects_with(Ml, "type Box T =\n value : T\nheld = Box(value = 7)\nprint \"${held.value}\"\n", ctor_arity_message("Box", 1, 2)); -/// "Function binders appear on a signature: `pick : (T, T) -> T`." -#[test] -fn ml_function_binders_live_on_the_signature() { - accepts( - Flavor::Ml, - "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n", - ); -} + /// "Function binders appear on a signature: `pick : (T, T) -> T`." + ml_function_binders_live_on_the_signature: accepts(Ml, "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n"); -/// "A binding without a signature cannot declare function type parameters." -#[test] -fn ml_a_binding_cannot_declare_type_parameters_without_a_signature() { - rejected_somehow( - Flavor::Ml, - "pick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n", - ); -} + /// "A binding without a signature cannot declare function type parameters." + ml_a_binding_cannot_declare_type_parameters_without_a_signature: rejected_somehow(Ml, "pick (first, second) = first\nkept = pick (10, 20)\nprint \"${kept}\"\n"); -/// The ML twin of the one-binder-relates-two-parameters rule. -#[test] -fn ml_one_binder_relates_two_parameters() { - rejects_with( - Flavor::Ml, - "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, \"twenty\")\nprint \"${kept}\"\n", - "cannot unify", - ); + /// The ML twin of the one-binder-relates-two-parameters rule. + ml_one_binder_relates_two_parameters: rejects_with(Ml, "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (10, \"twenty\")\nprint \"${kept}\"\n", "cannot unify"); } diff --git a/crates/osprey-types/src/generics_variance_assign_tests.rs b/crates/osprey-types/src/generics_variance_assign_tests.rs index 87e4f6f5..bfa13c8f 100644 --- a/crates/osprey-types/src/generics_variance_assign_tests.rs +++ b/crates/osprey-types/src/generics_variance_assign_tests.rs @@ -19,7 +19,7 @@ //! positions and silently misread a payload. Every claim is made at ALL THREE //! sites the spec names, because a rule enforced at one site is not the rule. -use crate::testutil::{accepts, rejects}; +use crate::testutil::{accepts, plain_cases, rejects, spec_cases}; use osprey_syntax::Flavor; /// The three assignment sites [TYPE-VARIANCE-ASSIGN] names, for a value of the @@ -93,67 +93,43 @@ const FNPAYLOAD: &str = "type Feed = Feed { supply: T } | Dry\n\ // [TYPE-VARIANCE-COERCION] — the coercion exists, at depth 0 only // --------------------------------------------------------------------------- -/// "A bare `T` satisfies a `Result` slot (an implicit `Success`)." -#[test] -fn the_coercion_holds_at_a_direct_value_site() { - flows("", "Result", "5"); -} +plain_cases! { + /// "A bare `T` satisfies a `Result` slot (an implicit `Success`)." + the_coercion_holds_at_a_direct_value_site: flows("", "Result", "5"); -/// "the inverse never holds anywhere." -#[test] -fn the_inverse_coercion_never_holds() { - blocked( - "fn half() -> Result = 20 * 5\n", - "int", - "half()", - ); + /// "the inverse never holds anywhere." + the_inverse_coercion_never_holds: blocked( "fn half() -> Result = 20 * 5\n", "int", "half()", ); } // --------------------------------------------------------------------------- // [TYPE-VARIANCE-COERCION] — and never inside an argument position // --------------------------------------------------------------------------- -/// "`Feed` does **not** satisfy a `Feed>` slot, -/// under `out T`" — the coercion would have to rebuild the container. -#[test] -fn a_covariant_argument_does_not_carry_the_coercion() { - blocked(FEED, "Feed>", "feedInt()"); -} +plain_cases! { + /// "`Feed` does **not** satisfy a `Feed>` slot, + /// under `out T`" — the coercion would have to rebuild the container. + a_covariant_argument_does_not_carry_the_coercion: blocked(FEED, "Feed>", "feedInt()"); -/// "…under `in T`" — the flipped recursion does not smuggle it in either. -#[test] -fn a_contravariant_argument_does_not_carry_the_coercion() { - blocked(GATE, "Gate", "gateRes()"); -} + /// "…under `in T`" — the flipped recursion does not smuggle it in either. + a_contravariant_argument_does_not_carry_the_coercion: blocked(GATE, "Gate", "gateRes()"); -/// "…or unannotated." -#[test] -fn an_invariant_argument_does_not_carry_the_coercion() { - blocked(CELL, "Cell>", "cellInt()"); -} + /// "…or unannotated." + an_invariant_argument_does_not_carry_the_coercion: blocked(CELL, "Cell>", "cellInt()"); -/// The unwrapping direction is refused under every marker too — the half the -/// shipped fixtures already cover, kept here so both directions sit together. -#[test] -fn no_marker_unwraps_a_result_payload() { - blocked(FEED, "Feed", "feedRes()"); - blocked(GATE, "Gate>", "gateInt()"); + /// The unwrapping direction is refused under every marker too — the half the + /// shipped fixtures already cover, kept here so both directions sit together. + no_marker_unwraps_a_result_payload: blocked(FEED, "Feed", "feedRes()"), + blocked(GATE, "Gate>", "gateInt()"), blocked(CELL, "Cell", "cellRes()"); -} -/// The identical instantiation is what all three markers DO accept. -#[test] -fn every_marker_accepts_the_identical_instantiation() { - flows(FEED, "Feed", "feedInt()"); - flows(GATE, "Gate", "gateInt()"); + /// The identical instantiation is what all three markers DO accept. + every_marker_accepts_the_identical_instantiation: flows(FEED, "Feed", "feedInt()"), + flows(GATE, "Gate", "gateInt()"), flows(CELL, "Cell", "cellInt()"); -} -/// And an unrelated payload is refused under every marker. -#[test] -fn every_marker_rejects_an_unrelated_payload() { - blocked(FEED, "Feed", "feedText()"); - blocked(GATE, "Gate", "gateText()"); + /// And an unrelated payload is refused under every marker. + every_marker_rejects_an_unrelated_payload: blocked(FEED, "Feed", "feedText()"), + blocked(GATE, "Gate", "gateText()"), blocked(CELL, "Cell", "cellText()"); } @@ -161,88 +137,44 @@ fn every_marker_rejects_an_unrelated_payload() { // Composition — depth does not unlock the coercion // --------------------------------------------------------------------------- -/// `out` inside `out` recurses, and still bottoms out exact. -#[test] -fn covariance_inside_covariance_still_bottoms_out_exact() { - blocked( - NESTED, - "Feed>>", - "feedFeedInt()", - ); +plain_cases! { + /// `out` inside `out` recurses, and still bottoms out exact. + covariance_inside_covariance_still_bottoms_out_exact: blocked( NESTED, "Feed>>", "feedFeedInt()", ), flows(NESTED, "Feed>", "feedFeedInt()"); -} -/// `in` inside `out` flips the recursion — and changes no outcome. -#[test] -fn contravariance_inside_covariance_still_bottoms_out_exact() { - blocked(NESTED, "Feed>", "feedGateRes()"); - blocked( - NESTED, - "Feed>>", - "feedGateInt()", - ); -} + /// `in` inside `out` flips the recursion — and changes no outcome. + contravariance_inside_covariance_still_bottoms_out_exact: blocked(NESTED, "Feed>", "feedGateRes()"), + blocked( NESTED, "Feed>>", "feedGateInt()", ); -/// `out` inside `in`, the other flip. -#[test] -fn covariance_inside_contravariance_still_bottoms_out_exact() { - blocked(NESTED, "Gate>", "gateFeedRes()"); -} + /// `out` inside `in`, the other flip. + covariance_inside_contravariance_still_bottoms_out_exact: blocked(NESTED, "Gate>", "gateFeedRes()"); -/// Two flips compose back to covariance, which is still exact. -#[test] -fn contravariance_inside_contravariance_still_bottoms_out_exact() { - blocked( - NESTED, - "Gate>>", - "gateGateInt()", - ); + /// Two flips compose back to covariance, which is still exact. + contravariance_inside_contravariance_still_bottoms_out_exact: blocked( NESTED, "Gate>>", "gateGateInt()", ), flows(NESTED, "Gate>", "gateGateInt()"); -} -/// An invariant argument under a covariant one. -#[test] -fn an_invariant_argument_under_a_covariant_one_is_exact() { - blocked( - NESTED, - "Feed>>", - "feedCellInt()", - ); + /// An invariant argument under a covariant one. + an_invariant_argument_under_a_covariant_one_is_exact: blocked( NESTED, "Feed>>", "feedCellInt()", ); } // --------------------------------------------------------------------------- // Function payloads: exact under a container, assignable when assigned direct // --------------------------------------------------------------------------- -/// "Function payloads match exactly for the same reason" — the parameter -/// position does not flip inside a container. -#[test] -fn a_function_payload_matches_exactly_inside_a_container() { - blocked(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesRes()"); - blocked( - FNPAYLOAD, - "Feed<(Result) -> bool>", - "feedTakesInt()", - ); -} +plain_cases! { + /// "Function payloads match exactly for the same reason" — the parameter + /// position does not flip inside a container. + a_function_payload_matches_exactly_inside_a_container: blocked(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesRes()"), + blocked( FNPAYLOAD, "Feed<(Result) -> bool>", "feedTakesInt()", ); -/// The spec's own counterexample, and its mirror: neither return direction -/// matches under a container. -#[test] -fn a_function_payloads_return_matches_exactly_inside_a_container() { - blocked(FNPAYLOAD, "Feed<(int) -> int>", "feedGivesRes()"); - blocked( - FNPAYLOAD, - "Feed<(int) -> Result>", - "feedGivesInt()", - ); -} + /// The spec's own counterexample, and its mirror: neither return direction + /// matches under a container. + a_function_payloads_return_matches_exactly_inside_a_container: blocked(FNPAYLOAD, "Feed<(int) -> int>", "feedGivesRes()"), + blocked( FNPAYLOAD, "Feed<(int) -> Result>", "feedGivesInt()", ); -/// The identical function payload flows, so the refusals above are about the -/// shape and not about function payloads being rejected wholesale. -#[test] -fn an_identical_function_payload_flows() { - flows(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesInt()"); + /// The identical function payload flows, so the refusals above are about the + /// shape and not about function payloads being rejected wholesale. + an_identical_function_payload_flows: flows(FNPAYLOAD, "Feed<(int) -> bool>", "feedTakesInt()"); } // --------------------------------------------------------------------------- @@ -289,45 +221,29 @@ fn the_three_markers_agree_on_every_assignment_outcome() { // The same rules through the ML surface ([FLAVOR-BOUNDARY]) // --------------------------------------------------------------------------- -/// The ML twin: a covariant ML container refuses the coercion too. -#[test] -fn ml_a_covariant_argument_does_not_carry_the_coercion() { - rejects( - Flavor::Ml, - "type Feed out T =\n supply : T\n\ +spec_cases! { + /// The ML twin: a covariant ML container refuses the coercion too. + ml_a_covariant_argument_does_not_carry_the_coercion: rejects(Ml, "type Feed out T =\n supply : T\n\ feedInt : Unit -> Feed\n\ feedInt () = Feed(supply = 1)\n\ takes : Feed> -> int\n\ takes v = 0\n\ held = takes (feedInt ())\n\ - print \"${held}\"\n", - ); -} + print \"${held}\"\n"); -/// The ML twin of the identical-instantiation acceptance, so the refusal above -/// is not an ML parsing accident. -#[test] -fn ml_an_identical_instantiation_flows() { - accepts( - Flavor::Ml, - "type Feed out T =\n supply : T\n\ + /// The ML twin of the identical-instantiation acceptance, so the refusal above + /// is not an ML parsing accident. + ml_an_identical_instantiation_flows: accepts(Ml, "type Feed out T =\n supply : T\n\ feedInt : Unit -> Feed\n\ feedInt () = Feed(supply = 1)\n\ takes : Feed -> int\n\ takes v = 0\n\ held = takes (feedInt ())\n\ - print \"${held}\"\n", - ); -} + print \"${held}\"\n"); -/// The ML twin of the direct-site coercion. -#[test] -fn ml_the_coercion_holds_at_a_direct_value_site() { - accepts( - Flavor::Ml, - "takes : Result -> int\n\ + /// The ML twin of the direct-site coercion. + ml_the_coercion_holds_at_a_direct_value_site: accepts(Ml, "takes : Result -> int\n\ takes v = 0\n\ held = takes 5\n\ - print \"${held}\"\n", - ); + print \"${held}\"\n"); } diff --git a/crates/osprey-types/src/generics_variance_builtin_tests.rs b/crates/osprey-types/src/generics_variance_builtin_tests.rs index dbcb24d1..a0703bac 100644 --- a/crates/osprey-types/src/generics_variance_builtin_tests.rs +++ b/crates/osprey-types/src/generics_variance_builtin_tests.rs @@ -16,6 +16,7 @@ //! the day that changes, and the function rules are checked as live behaviour. use crate::generics_variance_assign_tests::{accepted, blocked, flows, sites}; +use crate::testutil::plain_cases; /// Producers for every built-in shape under test, at both instantiations. const BUILTINS: &str = "fn listInt() -> List = [1]\n\ @@ -36,83 +37,47 @@ const BUILTINS: &str = "fn listInt() -> List = [1]\n\ // The constructor entries: identical instantiations flow, coercions do not // --------------------------------------------------------------------------- -/// `List` accepts its own element type… -#[test] -fn list_accepts_the_identical_element() { - flows(BUILTINS, "List", "listInt()"); -} +plain_cases! { + /// `List` accepts its own element type… + list_accepts_the_identical_element: flows(BUILTINS, "List", "listInt()"); -/// …refuses the coercion in both directions… -#[test] -fn list_refuses_the_coercion_in_both_directions() { - blocked(BUILTINS, "List>", "listInt()"); + /// …refuses the coercion in both directions… + list_refuses_the_coercion_in_both_directions: blocked(BUILTINS, "List>", "listInt()"), blocked(BUILTINS, "List", "listRes()"); -} -/// …and refuses an unrelated element. -#[test] -fn list_rejects_an_unrelated_element() { - blocked(BUILTINS, "List", "listInt()"); -} + /// …and refuses an unrelated element. + list_rejects_an_unrelated_element: blocked(BUILTINS, "List", "listInt()"); -/// `Result`: neither channel carries the coercion inward. -#[test] -fn result_refuses_the_coercion_in_either_channel() { - blocked( - BUILTINS, - "Result, MathError>", - "resInt()", - ); - blocked( - BUILTINS, - "Result>", - "resInt()", - ); -} + /// `Result`: neither channel carries the coercion inward. + result_refuses_the_coercion_in_either_channel: blocked( BUILTINS, "Result, MathError>", "resInt()", ), + blocked( BUILTINS, "Result>", "resInt()", ); -/// The identical `Result` instantiation flows. -#[test] -fn result_accepts_the_identical_instantiation() { - flows(BUILTINS, "Result", "resInt()"); -} + /// The identical `Result` instantiation flows. + result_accepts_the_identical_instantiation: flows(BUILTINS, "Result", "resInt()"); -/// `Fiber`: same story for a fiber's answer. -#[test] -fn fiber_refuses_the_coercion_and_accepts_its_own_answer() { - blocked(BUILTINS, "Fiber>", "fiberInt()"); - blocked(BUILTINS, "Fiber", "fiberInt()"); + /// `Fiber`: same story for a fiber's answer. + fiber_refuses_the_coercion_and_accepts_its_own_answer: blocked(BUILTINS, "Fiber>", "fiberInt()"), + blocked(BUILTINS, "Fiber", "fiberInt()"), flows(BUILTINS, "Fiber", "fiberInt()"); -} -/// `Map`: the value channel refuses the coercion… -#[test] -fn map_refuses_the_coercion_in_its_value() { - blocked(BUILTINS, "Map>", "mapInt()"); + /// `Map`: the value channel refuses the coercion… + map_refuses_the_coercion_in_its_value: blocked(BUILTINS, "Map>", "mapInt()"), blocked(BUILTINS, "Map", "mapRes()"); -} -/// The key channel cannot be exercised for variance at all: the shipped map -/// surface fixes keys to `string` ([BUILTIN-MAP-GET], spec 0012), so -/// `Map` has no producer and `Map`'s "(keys invariant)" -/// describes a parameter no program can instantiate. Recorded as a spec/ -/// implementation conflict in plan 0015 rather than asserted as behaviour; what -/// IS assertable is that a non-string key is refused. -#[test] -fn a_non_string_map_key_is_refused() { - blocked(BUILTINS, "Map", "mapInt()"); -} + /// The key channel cannot be exercised for variance at all: the shipped map + /// surface fixes keys to `string` ([BUILTIN-MAP-GET], spec 0012), so + /// `Map` has no producer and `Map`'s "(keys invariant)" + /// describes a parameter no program can instantiate. Recorded as a spec/ + /// implementation conflict in plan 0015 rather than asserted as behaviour; what + /// IS assertable is that a non-string key is refused. + a_non_string_map_key_is_refused: blocked(BUILTINS, "Map", "mapInt()"); -/// The identical map instantiation flows. -#[test] -fn map_accepts_the_identical_instantiation() { - flows(BUILTINS, "Map", "mapInt()"); -} + /// The identical map instantiation flows. + map_accepts_the_identical_instantiation: flows(BUILTINS, "Map", "mapInt()"); -/// `Channel` is invariant, and behaves exactly as the covariant entries do. -#[test] -fn channel_refuses_the_coercion_in_both_directions() { - blocked(BUILTINS, "Channel>", "chanInt()"); - blocked(BUILTINS, "Channel", "chanRes()"); + /// `Channel` is invariant, and behaves exactly as the covariant entries do. + channel_refuses_the_coercion_in_both_directions: blocked(BUILTINS, "Channel>", "chanInt()"), + blocked(BUILTINS, "Channel", "chanRes()"), flows(BUILTINS, "Channel", "chanInt()"); } @@ -135,43 +100,27 @@ fn the_covariant_and_invariant_builtins_agree() { // Function types — the half of the table that DOES bite // --------------------------------------------------------------------------- -/// "structurally contravariant in parameters": a function accepting a `Result` -/// stands where one accepting an `int` is expected, because the parameter -/// recursion applies the coercion at a direct site. -#[test] -fn a_function_slot_is_contravariant_in_its_parameter() { - flows(BUILTINS, "(int) -> bool", "takesRes"); -} +plain_cases! { + /// "structurally contravariant in parameters": a function accepting a `Result` + /// stands where one accepting an `int` is expected, because the parameter + /// recursion applies the coercion at a direct site. + a_function_slot_is_contravariant_in_its_parameter: flows(BUILTINS, "(int) -> bool", "takesRes"); -/// The widened direction is refused. -#[test] -fn a_function_slot_rejects_a_widened_parameter() { - blocked(BUILTINS, "(Result) -> bool", "takesInt"); -} + /// The widened direction is refused. + a_function_slot_rejects_a_widened_parameter: blocked(BUILTINS, "(Result) -> bool", "takesInt"); -/// "and covariant in returns": a function returning `int` stands where one -/// returning `Result` is expected. -#[test] -fn a_function_slot_is_covariant_in_its_return() { - flows(BUILTINS, "(int) -> Result", "givesInt"); -} + /// "and covariant in returns": a function returning `int` stands where one + /// returning `Result` is expected. + a_function_slot_is_covariant_in_its_return: flows(BUILTINS, "(int) -> Result", "givesInt"); -/// The unwrapping direction is refused. -#[test] -fn a_function_slot_never_unwraps_its_return() { - blocked(BUILTINS, "(int) -> int", "givesRes"); -} + /// The unwrapping direction is refused. + a_function_slot_never_unwraps_its_return: blocked(BUILTINS, "(int) -> int", "givesRes"); -/// The identical shape flows. -#[test] -fn a_function_slot_accepts_the_identical_shape() { - flows(BUILTINS, "(int) -> bool", "takesInt"); -} + /// The identical shape flows. + a_function_slot_accepts_the_identical_shape: flows(BUILTINS, "(int) -> bool", "takesInt"); -/// Arity is checked before any of this. -#[test] -fn a_function_slot_rejects_an_arity_mismatch() { - blocked(BUILTINS, "(int, int) -> bool", "takesInt"); + /// Arity is checked before any of this. + a_function_slot_rejects_an_arity_mismatch: blocked(BUILTINS, "(int, int) -> bool", "takesInt"); } /// The function rules and the constructor rules are the SAME relation applied diff --git a/crates/osprey-types/src/generics_variance_shape_tests.rs b/crates/osprey-types/src/generics_variance_shape_tests.rs index 40b921eb..8f2616ea 100644 --- a/crates/osprey-types/src/generics_variance_shape_tests.rs +++ b/crates/osprey-types/src/generics_variance_shape_tests.rs @@ -8,63 +8,31 @@ //! and `position_message` helpers this module reuses. use crate::generics_variance_tests::{decl, position_message}; -use crate::testutil::{accepts, check, rejected_somehow, rejects_with}; +use crate::testutil::{accepts, check, rejected_somehow, spec_cases}; use osprey_syntax::Flavor; -/// A function type inside a covariant built-in still flips its parameter. -#[test] -fn out_in_a_function_parameter_inside_a_list_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "checks", "List<(T) -> int>"), - &position_message("T", "out", "input", "checks", "Holder"), - ); -} +spec_cases! { + /// A function type inside a covariant built-in still flips its parameter. + out_in_a_function_parameter_inside_a_list_is_rejected: rejects_with(Default, decl("", "checks", "List<(T) -> int>"), position_message("T", "out", "input", "checks", "Holder")); -/// The `Result` ERROR channel is an output position too. -#[test] -fn out_is_legal_in_the_result_error_channel() { - accepts( - Flavor::Default, - &decl("", "failure", "Result"), - ); -} + /// The `Result` ERROR channel is an output position too. + out_is_legal_in_the_result_error_channel: accepts(Default, decl("", "failure", "Result")); -/// …so a contravariant parameter is rejected there. -#[test] -fn in_in_the_result_error_channel_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "failure", "Result"), - &position_message("T", "in", "output", "failure", "Holder"), - ); -} + /// …so a contravariant parameter is rejected there. + in_in_the_result_error_channel_is_rejected: rejects_with(Default, decl("", "failure", "Result"), position_message("T", "in", "output", "failure", "Holder")); -/// `Fiber` is an output position, so `in T` cannot sit there. -#[test] -fn in_inside_a_fiber_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "worker", "Fiber"), - &position_message("T", "in", "output", "worker", "Holder"), - ); -} + /// `Fiber` is an output position, so `in T` cannot sit there. + in_inside_a_fiber_is_rejected: rejects_with(Default, decl("", "worker", "Fiber"), position_message("T", "in", "output", "worker", "Holder")); -/// `Map`: a contravariant parameter is rejected in the VALUE channel. -#[test] -fn in_in_a_map_value_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "byName", "Map"), - &position_message("T", "in", "output", "byName", "Holder"), - ); + /// `Map`: a contravariant parameter is rejected in the VALUE channel. + in_in_a_map_value_is_rejected: rejects_with(Default, decl("", "byName", "Map"), position_message("T", "in", "output", "byName", "Holder")); } /// …and in the invariant KEY channel, both markers are refused. #[test] fn map_keys_refuse_both_markers() { - rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); - rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); + rejected_somehow(Flavor::Default, decl("", "byKey", "Map")); + rejected_somehow(Flavor::Default, decl("", "byKey", "Map")); } // --------------------------------------------------------------------------- @@ -77,43 +45,24 @@ fn both_positions(params: &str) -> String { format!("type Holder{params} = {{ held: T, consume: (T) -> int }}\nprint(\"declared\")") } -/// The invariant spelling is accepted. -#[test] -fn a_parameter_used_in_both_positions_may_be_invariant() { - accepts(Flavor::Default, &both_positions("")); -} +spec_cases! { + /// The invariant spelling is accepted. + a_parameter_used_in_both_positions_may_be_invariant: accepts(Default, both_positions("")); -/// The covariant spelling is rejected on the input half. -#[test] -fn a_parameter_used_in_both_positions_may_not_be_covariant() { - rejects_with( - Flavor::Default, - &both_positions(""), - &position_message("T", "out", "input", "consume", "Holder"), - ); -} + /// The covariant spelling is rejected on the input half. + a_parameter_used_in_both_positions_may_not_be_covariant: rejects_with(Default, both_positions(""), position_message("T", "out", "input", "consume", "Holder")); -/// The contravariant spelling is rejected on the output half. -#[test] -fn a_parameter_used_in_both_positions_may_not_be_contravariant() { - rejects_with( - Flavor::Default, - &both_positions(""), - &position_message("T", "in", "output", "held", "Holder"), - ); + /// The contravariant spelling is rejected on the output half. + a_parameter_used_in_both_positions_may_not_be_contravariant: rejects_with(Default, both_positions(""), position_message("T", "in", "output", "held", "Holder")); } // --------------------------------------------------------------------------- // [TYPE-VARIANCE-DECL] — several parameters, each checked on its own // --------------------------------------------------------------------------- -/// Mixed markers on one declaration are checked independently. -#[test] -fn mixed_markers_are_checked_per_parameter() { - accepts( - Flavor::Default, - "type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")", - ); +spec_cases! { + /// Mixed markers on one declaration are checked independently. + mixed_markers_are_checked_per_parameter: accepts(Default, "type Two = { give: A, take: (B) -> bool }\nprint(\"declared\")"); } /// Swapping the two markers puts each parameter in the wrong position. @@ -138,23 +87,12 @@ fn swapped_markers_are_rejected_per_parameter() { // [TYPE-VARIANCE-POSITIONS] — union variants, including positional payloads // --------------------------------------------------------------------------- -/// A union variant's payload is an output position. -#[test] -fn out_is_legal_in_a_union_variant_payload() { - accepts( - Flavor::Default, - "type Maybe = Some { value: T } | None\nprint(\"declared\")", - ); -} +spec_cases! { + /// A union variant's payload is an output position. + out_is_legal_in_a_union_variant_payload: accepts(Default, "type Maybe = Some { value: T } | None\nprint(\"declared\")"); -/// …so a contravariant parameter is rejected there. -#[test] -fn in_in_a_union_variant_payload_is_rejected() { - rejects_with( - Flavor::Default, - "type Maybe = Some { value: T } | None\nprint(\"declared\")", - &position_message("T", "in", "output", "value", "Maybe"), - ); + /// …so a contravariant parameter is rejected there. + in_in_a_union_variant_payload_is_rejected: rejects_with(Default, "type Maybe = Some { value: T } | None\nprint(\"declared\")", position_message("T", "in", "output", "value", "Maybe")); } /// A POSITIONAL payload is the same output position under a different spelling @@ -171,12 +109,7 @@ fn a_positional_variant_payload_is_an_output_position() { ); } -/// Every variant is walked, not just the first. -#[test] -fn a_violation_in_a_later_variant_is_still_found() { - rejects_with( - Flavor::Default, - "type Split = First { ok: T } | Second { consume: (T) -> int } | Empty\nprint(\"declared\")", - &position_message("T", "out", "input", "consume", "Split"), - ); +spec_cases! { + /// Every variant is walked, not just the first. + a_violation_in_a_later_variant_is_still_found: rejects_with(Default, "type Split = First { ok: T } | Second { consume: (T) -> int } | Empty\nprint(\"declared\")", position_message("T", "out", "input", "consume", "Split")); } diff --git a/crates/osprey-types/src/generics_variance_tests.rs b/crates/osprey-types/src/generics_variance_tests.rs index ccdf86a4..4a860953 100644 --- a/crates/osprey-types/src/generics_variance_tests.rs +++ b/crates/osprey-types/src/generics_variance_tests.rs @@ -11,7 +11,9 @@ //! it — a wrong entry in that table shows up as a position that should have //! been rejected and was not. -use crate::testutil::{accepts, rejected_somehow, rejects_with, variance_position_message}; +use crate::testutil::{ + accepts, rejected_somehow, rejects_with, spec_cases, variance_position_message, +}; use osprey_syntax::Flavor; /// The position diagnostic for a type declaration's FIELD. @@ -34,168 +36,91 @@ pub(crate) fn decl(params: &str, field: &str, ty: &str) -> String { // [TYPE-VARIANCE-POSITIONS] — output positions // --------------------------------------------------------------------------- -/// A field is an OUTPUT position, so `out T` belongs there. -#[test] -fn out_is_legal_in_a_field() { - accepts(Flavor::Default, &decl("", "supply", "T")); -} +spec_cases! { + /// A field is an OUTPUT position, so `out T` belongs there. + out_is_legal_in_a_field: accepts(Default, decl("", "supply", "T")); -/// A function RESULT is an output position, so `out T` belongs there too. -#[test] -fn out_is_legal_in_a_function_result() { - accepts(Flavor::Default, &decl("", "make", "(int) -> T")); -} + /// A function RESULT is an output position, so `out T` belongs there too. + out_is_legal_in_a_function_result: accepts(Default, decl("", "make", "(int) -> T")); -/// A function PARAMETER flips the polarity to input: `out T` is rejected. -#[test] -fn out_in_a_function_parameter_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "consume", "(T) -> int"), - &position_message("T", "out", "input", "consume", "Holder"), - ); -} + /// A function PARAMETER flips the polarity to input: `out T` is rejected. + out_in_a_function_parameter_is_rejected: rejects_with(Default, decl("", "consume", "(T) -> int"), position_message("T", "out", "input", "consume", "Holder")); -/// Two flips compose back to an output position, so `out T` is legal again. -#[test] -fn out_under_two_parameter_flips_is_legal() { - accepts( - Flavor::Default, - &decl("", "hof", "((T) -> int) -> int"), - ); -} + /// Two flips compose back to an output position, so `out T` is legal again. + out_under_two_parameter_flips_is_legal: accepts(Default, decl("", "hof", "((T) -> int) -> int")); -/// An `in` parameter belongs in an input position. -#[test] -fn in_is_legal_in_a_function_parameter() { - accepts(Flavor::Default, &decl("", "admit", "(T) -> bool")); -} + /// An `in` parameter belongs in an input position. + in_is_legal_in_a_function_parameter: accepts(Default, decl("", "admit", "(T) -> bool")); -/// A field is an output position, so `in T` is rejected there. -#[test] -fn in_in_a_field_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "held", "T"), - &position_message("T", "in", "output", "held", "Holder"), - ); -} + /// A field is an output position, so `in T` is rejected there. + in_in_a_field_is_rejected: rejects_with(Default, decl("", "held", "T"), position_message("T", "in", "output", "held", "Holder")); -/// A function result is an output position, so `in T` is rejected there. -#[test] -fn in_in_a_function_result_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "make", "(int) -> T"), - &position_message("T", "in", "output", "make", "Holder"), - ); -} + /// A function result is an output position, so `in T` is rejected there. + in_in_a_function_result_is_rejected: rejects_with(Default, decl("", "make", "(int) -> T"), position_message("T", "in", "output", "make", "Holder")); -/// Two flips compose back to output, so `in T` is rejected under them. -#[test] -fn in_under_two_parameter_flips_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "hof", "((T) -> int) -> int"), - &position_message("T", "in", "output", "hof", "Holder"), - ); + /// Two flips compose back to output, so `in T` is rejected under them. + in_under_two_parameter_flips_is_rejected: rejects_with(Default, decl("", "hof", "((T) -> int) -> int"), position_message("T", "in", "output", "hof", "Holder")); } /// An unannotated parameter is invariant and sits in EITHER position. #[test] fn an_invariant_parameter_is_legal_in_both_positions() { - accepts(Flavor::Default, &decl("", "held", "T")); - accepts(Flavor::Default, &decl("", "consume", "(T) -> int")); + accepts(Flavor::Default, decl("", "held", "T")); + accepts(Flavor::Default, decl("", "consume", "(T) -> int")); } // --------------------------------------------------------------------------- // [TYPE-VARIANCE-POSITIONS] — composition through a nested constructor // --------------------------------------------------------------------------- -/// A covariant argument of a covariant constructor keeps the position. -#[test] -fn out_inside_a_covariant_constructor_argument_is_legal() { - accepts( - Flavor::Default, - &format!( +spec_cases! { + /// A covariant argument of a covariant constructor keeps the position. + out_inside_a_covariant_constructor_argument_is_legal: accepts(Default, format!( "type Feed = {{ supply: A }}\n{}", decl("", "nested", "Feed") - ), - ); -} + )); -/// A covariant argument of a CONTRAVARIANT constructor flips the position. -#[test] -fn out_inside_a_contravariant_constructor_argument_is_rejected() { - rejects_with( - Flavor::Default, - &format!( + /// A covariant argument of a CONTRAVARIANT constructor flips the position. + out_inside_a_contravariant_constructor_argument_is_rejected: rejects_with(Default, format!( "type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate") - ), - &position_message("T", "out", "input", "nested", "Holder"), - ); -} + ), position_message("T", "out", "input", "nested", "Holder")); -/// The mirror composes the other way and is LEGAL: a field is an output -/// position, the contravariant argument flips it to input, and an input -/// position is exactly where `in T` belongs (output x contravariant = input). -#[test] -fn in_inside_a_contravariant_constructor_argument_is_legal() { - accepts( - Flavor::Default, - &format!( + /// The mirror composes the other way and is LEGAL: a field is an output + /// position, the contravariant argument flips it to input, and an input + /// position is exactly where `in T` belongs (output x contravariant = input). + in_inside_a_contravariant_constructor_argument_is_legal: accepts(Default, format!( "type Gate = {{ admit: (A) -> bool }}\n{}", decl("", "nested", "Gate") - ), - ); -} + )); -/// "an invariant argument position demands both directions, so only invariant -/// parameters may sit there" — a covariant parameter may not. -#[test] -fn out_inside_an_invariant_constructor_argument_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!( + /// "an invariant argument position demands both directions, so only invariant + /// parameters may sit there" — a covariant parameter may not. + out_inside_an_invariant_constructor_argument_is_rejected: rejected_somehow(Default, format!( "type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell") - ), - ); -} + )); -/// …nor may a contravariant one. -#[test] -fn in_inside_an_invariant_constructor_argument_is_rejected() { - rejected_somehow( - Flavor::Default, - &format!( + /// …nor may a contravariant one. + in_inside_an_invariant_constructor_argument_is_rejected: rejected_somehow(Default, format!( "type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell") - ), - ); -} + )); -/// An invariant parameter is exactly what an invariant argument accepts. -#[test] -fn an_invariant_parameter_inside_an_invariant_argument_is_legal() { - accepts( - Flavor::Default, - &format!( + /// An invariant parameter is exactly what an invariant argument accepts. + an_invariant_parameter_inside_an_invariant_argument_is_legal: accepts(Default, format!( "type Cell = {{ slot: A }}\n{}", decl("", "nested", "Cell") - ), - ); + )); } // --------------------------------------------------------------------------- // [TYPE-VARIANCE-ASSIGN] — the built-in variance table, checked by position // --------------------------------------------------------------------------- -/// `List`: a covariant parameter may sit in its argument. -#[test] -fn list_is_covariant_in_its_element() { - accepts(Flavor::Default, &decl("", "items", "List")); +spec_cases! { + /// `List`: a covariant parameter may sit in its argument. + list_is_covariant_in_its_element: accepts(Default, decl("", "items", "List")); } /// `Result`: both arguments are covariant. @@ -203,50 +128,35 @@ fn list_is_covariant_in_its_element() { fn result_is_covariant_in_both_arguments() { accepts( Flavor::Default, - &decl("", "value", "Result"), + decl("", "value", "Result"), ); accepts( Flavor::Default, - &decl("", "failure", "Result"), + decl("", "failure", "Result"), ); } -/// `Fiber`: covariant in its answer. -#[test] -fn fiber_is_covariant_in_its_answer() { - accepts(Flavor::Default, &decl("", "worker", "Fiber")); -} +spec_cases! { + /// `Fiber`: covariant in its answer. + fiber_is_covariant_in_its_answer: accepts(Default, decl("", "worker", "Fiber")); -/// `Map`: the VALUE is covariant. -#[test] -fn map_is_covariant_in_its_value() { - accepts( - Flavor::Default, - &decl("", "byName", "Map"), - ); -} + /// `Map`: the VALUE is covariant. + map_is_covariant_in_its_value: accepts(Default, decl("", "byName", "Map")); -/// `Map`: the KEY is invariant, so a covariant parameter is rejected. -#[test] -fn map_keys_are_invariant() { - rejected_somehow(Flavor::Default, &decl("", "byKey", "Map")); + /// `Map`: the KEY is invariant, so a covariant parameter is rejected. + map_keys_are_invariant: rejected_somehow(Default, decl("", "byKey", "Map")); } /// `Channel` is invariant in both directions. #[test] fn channel_is_invariant() { - rejected_somehow(Flavor::Default, &decl("", "wire", "Channel")); - rejected_somehow(Flavor::Default, &decl("", "wire", "Channel")); + rejected_somehow(Flavor::Default, decl("", "wire", "Channel")); + rejected_somehow(Flavor::Default, decl("", "wire", "Channel")); } -/// A `List` of a contravariant parameter is an output position. -#[test] -fn in_inside_a_list_is_rejected() { - rejects_with( - Flavor::Default, - &decl("", "items", "List"), - &position_message("T", "in", "output", "items", "Holder"), - ); +spec_cases! { + /// A `List` of a contravariant parameter is an output position. + in_inside_a_list_is_rejected: rejects_with(Default, decl("", "items", "List"), position_message("T", "in", "output", "items", "Holder")); } // --------------------------------------------------------------------------- @@ -267,66 +177,41 @@ print("${{firstItem(mkFeed())}}")"# ) } -/// Under `out T`. -#[test] -fn a_result_payload_does_not_collapse_under_a_covariant_container() { - rejects_with( - Flavor::Default, - &feed_payload_program("out "), - "cannot unify", - ); -} +spec_cases! { + /// Under `out T`. + a_result_payload_does_not_collapse_under_a_covariant_container: rejects_with(Default, feed_payload_program("out "), "cannot unify"); -/// Under an invariant parameter. -#[test] -fn a_result_payload_does_not_collapse_under_an_invariant_container() { - rejects_with(Flavor::Default, &feed_payload_program(""), "cannot unify"); -} + /// Under an invariant parameter. + a_result_payload_does_not_collapse_under_an_invariant_container: rejects_with(Default, feed_payload_program(""), "cannot unify"); -/// "Function returns also match exactly, so a `Feed<(int) -> Result>` -/// does not match a `Feed<(int) -> int>` slot" — the spec's own example. -#[test] -fn a_function_payloads_return_channel_matches_exactly() { - rejects_with( - Flavor::Default, - r#"type Feed = Feed { supply: T } | Dry + /// "Function returns also match exactly, so a `Feed<(int) -> Result>` + /// does not match a `Feed<(int) -> int>` slot" — the spec's own example. + a_function_payloads_return_channel_matches_exactly: rejects_with(Default, r#"type Feed = Feed { supply: T } | Dry fn label(f: Feed<(int) -> int>) = match f { Feed { supply } => "supplied" Dry => "dry" } fn mkFeed() -> Feed<(int) -> Result> = Feed { supply: |n| => n * 2 } -print(label(mkFeed()))"#, - "cannot unify", - ); -} +print(label(mkFeed()))"#, "cannot unify"); -/// The direct value site keeps the one safe promotion `T -> Result`, -/// which is what makes the container rejections above a real restriction rather -/// than a blanket ban. -#[test] -fn the_direct_site_promotion_still_holds() { - accepts( - Flavor::Default, - r#"fn keep(n: Result) = n ?: 0 -print("${keep(5)}")"#, - ); + /// The direct value site keeps the one safe promotion `T -> Result`, + /// which is what makes the container rejections above a real restriction rather + /// than a blanket ban. + the_direct_site_promotion_still_holds: accepts(Default, r#"fn keep(n: Result) = n ?: 0 +print("${keep(5)}")"#); } // --------------------------------------------------------------------------- // [TYPE-VARIANCE-DECL] — where the markers may be written at all // --------------------------------------------------------------------------- -/// "`out` and `in` are contextual keywords, reserved only inside -/// type-parameter lists" — they stay usable as ordinary names. -#[test] -fn out_and_in_stay_legal_identifiers_outside_a_parameter_list() { - accepts( - Flavor::Default, - r#"let out = 1 +spec_cases! { + /// "`out` and `in` are contextual keywords, reserved only inside + /// type-parameter lists" — they stay usable as ordinary names. + out_and_in_stay_legal_identifiers_outside_a_parameter_list: accepts(Default, r#"let out = 1 let inn = 2 fn keep(out) = out -print("${keep(out)} ${inn}")"#, - ); +print("${keep(out)} ${inn}")"#); } /// Variance is declaration-site on TYPES and EFFECTS only — never on a @@ -362,7 +247,7 @@ fn ml_variance_binders_check_the_same_positions() { rejects_with( Flavor::Ml, "type Bad out T =\n consume : T -> int\nprint \"declared\"\n", - &position_message("T", "out", "input", "consume", "Bad"), + position_message("T", "out", "input", "consume", "Bad"), ); } @@ -376,16 +261,11 @@ fn ml_contravariant_binders_check_the_same_positions() { rejects_with( Flavor::Ml, "type Bad in T =\n held : T\nprint \"declared\"\n", - &position_message("T", "in", "output", "held", "Bad"), + position_message("T", "in", "output", "held", "Bad"), ); } -/// ML function binders reject variance exactly as Default's do. -#[test] -fn ml_a_variance_marker_on_a_function_binder_is_rejected() { - rejects_with( - Flavor::Ml, - "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (1, 2)\nprint \"${kept}\"\n", - "variance annotations are only valid on type and effect declarations", - ); +spec_cases! { + /// ML function binders reject variance exactly as Default's do. + ml_a_variance_marker_on_a_function_binder_is_rejected: rejects_with(Ml, "pick : (T, T) -> T\npick (first, second) = first\nkept = pick (1, 2)\nprint \"${kept}\"\n", "variance annotations are only valid on type and effect declarations"); } diff --git a/crates/osprey-types/src/lib.rs b/crates/osprey-types/src/lib.rs index eea0b6c5..e9a917a4 100644 --- a/crates/osprey-types/src/lib.rs +++ b/crates/osprey-types/src/lib.rs @@ -29,6 +29,8 @@ mod effect_rows_exports_tests; mod effect_rows_expr_tests; #[cfg(test)] mod effect_rows_tests; +#[cfg(test)] +mod effect_rows_transport_tests; mod env; mod error; mod expr; @@ -59,6 +61,9 @@ mod redundant_sites; #[cfg(test)] mod redundant_tests; #[cfg(test)] +#[path = "../../testkit.rs"] +mod testkit; +#[cfg(test)] mod testutil; mod ty; mod unify; diff --git a/crates/osprey-types/src/methods.rs b/crates/osprey-types/src/methods.rs index 085f661b..fd7fc681 100644 --- a/crates/osprey-types/src/methods.rs +++ b/crates/osprey-types/src/methods.rs @@ -22,6 +22,20 @@ pub(crate) struct Parts<'a> { pub application: Option<(&'a [TypeExpr], Option)>, } +/// `function` wrapped in the call site's explicit type application, or left +/// alone when the site wrote no turbofish — the one rule both the deferred +/// method-call rewrite and the ordinary call rewrite apply. +fn applied(function: Expr, application: Option<(&[TypeExpr], Option)>) -> Expr { + match application { + Some((type_args, position)) => Expr::TypeApply { + function: Box::new(function), + type_args: type_args.to_vec(), + position, + }, + None => function, + } +} + pub(crate) fn parts(expression: &Expr) -> Option> { match expression { Expr::MethodCall { @@ -104,14 +118,7 @@ pub(crate) fn lower(expression: &mut Expr, target: &Target) { arguments: parts.arguments.to_vec(), named_arguments: parts.named.to_vec(), }; - *expression = match parts.application { - Some((args, position)) => Expr::TypeApply { - function: Box::new(call), - type_args: args.to_vec(), - position, - }, - None => call, - }; + *expression = applied(call, parts.application); return; } let mut arguments = parts.arguments.to_vec(); @@ -124,14 +131,7 @@ pub(crate) fn lower(expression: &mut Expr, target: &Target) { arguments.insert(0, parts.target.clone()); Expr::Identifier(parts.method.to_owned()) }; - let function = match parts.application { - Some((type_args, position)) => Expr::TypeApply { - function: Box::new(function), - type_args: type_args.to_vec(), - position, - }, - None => function, - }; + let function = applied(function, parts.application); *expression = Expr::Call { function: Box::new(function), arguments, @@ -284,3 +284,131 @@ fn unpack_obligations(obligations: &Type) -> Vec<(String, Type)> { }) .collect() } + +#[cfg(test)] +mod tests { + use crate::testutil::{accepts, rejects_with}; + use osprey_syntax::Flavor; + + #[test] + fn a_generic_receiver_selects_its_field_before_a_same_named_function() { + accepts( + Flavor::Default, + r#"type Action = Action { m: () -> int } +fn field() -> int = 11 +fn m(x: T) -> string = "free" +fn invoke(x: T) = x.m() +fn recordResult() -> int = invoke(Action { m: field }) +fn scalarResult() -> string = invoke(3) +print("${recordResult()} ${scalarResult()}")"#, + ); + } + + #[test] + fn deferred_named_arguments_follow_the_selected_free_functions_parameter_order() { + for application in ["choose", "choose"] { + accepts( + Flavor::Default, + format!( + r#"fn choose(receiver: T, text: string, count: int) = "${{text}} ${{count}}" +fn invoke(receiver: T) = receiver.{application}(count: 7, text: "generic") +fn result() -> string = invoke(4) +print(result())"# + ), + ); + } + } + + #[test] + fn field_dispatch_keeps_only_the_selected_callees_constraints() { + accepts( + Flavor::Default, + r#"type Action = Action { m: () -> bool } +fn field() -> bool = true +fn m(x: T) = length(x) +fn invoke(x: T) = x.m() +fn recordResult() -> bool = invoke(Action { m: field }) +fn stringResult() -> int = invoke("abc") +fn listResult() -> int = invoke([1, 2]) +print("${recordResult()} ${stringResult()} ${listResult()}")"#, + ); + } + + #[test] + fn a_generic_callback_field_keeps_its_argument_and_return_contract() { + let declarations = r"type Sink = Sink { hof: ((int) -> T) -> int } +fn callbackResult(f) = 7 +fn invoke(g) = g.hof(|n| => 3) +"; + accepts( + Flavor::Default, + format!( + "{declarations}fn result() -> int = invoke(Sink {{ hof: callbackResult }})\n" + ), + ); + rejects_with( + Flavor::Default, + format!("{declarations}fn result() -> int = invoke(Sink {{ hof: callbackResult }})\n"), + "cannot unify", + ); + } + + #[test] + fn a_field_cannot_borrow_a_same_named_functions_explicit_binders() { + for invocation in [ + "fn result() = Action { m: field }.m()", + "fn invoke(x: T) = x.m()\nfn result() = invoke(Action { m: field })", + ] { + rejects_with( + Flavor::Default, + format!( + "type Action = Action {{ m: () -> int }}\nfn field() = 11\nfn m(x: T) = 22\n{invocation}\n" + ), + "function `m` takes 0 type argument(s), got 1", + ); + } + } + + #[test] + fn a_deferred_free_function_checks_written_binder_arity_and_value_types() { + for (application, message) in [ + ( + "m", + "function `m` takes 1 type argument(s), got 2", + ), + ("m", "cannot unify"), + ] { + rejects_with( + Flavor::Default, + format!("fn m(x: T) = x\nfn invoke(x: T) = x.{application}()\nfn result() = invoke(3)\n"), + message, + ); + } + } + + #[test] + fn explicit_arguments_validate_nested_types_and_enclosing_binders() { + for (argument, message) in [ + ("T", "type parameter `T` cannot take type arguments"), + ( + "List>", + "type parameter `T` cannot take type arguments", + ), + ("int", "type `int` takes 0 type argument(s), got 1"), + ( + "List", + "type `List` takes 1 type argument(s), got 2", + ), + ("(Unknown) -> int", "unknown type `Unknown`"), + ("(int) -> Unknown", "unknown type `Unknown`"), + ] { + rejects_with( + Flavor::Default, + format!( + "fn empty() -> List = []\nfn invoke(x: T) = empty<{argument}>()\n" + ), + message, + ); + } + } +} diff --git a/crates/osprey-types/src/pattern.rs b/crates/osprey-types/src/pattern.rs index 35a581d5..03feff83 100644 --- a/crates/osprey-types/src/pattern.rs +++ b/crates/osprey-types/src/pattern.rs @@ -141,12 +141,7 @@ impl Checker { // row and an erased one: a repeated field name makes the two halves of // the compiler disagree about the same pattern. if self.reject_duplicate_fields(fields) { - for (_, binder) in fields { - if !binder.is_empty() { - let fv = self.ctx.fresh(); - local.insert(binder.clone(), Scheme::mono(fv)); - } - } + self.bind_fresh(fields, local); return; } let dp = self.ctx.prune(disc); @@ -168,12 +163,7 @@ impl Checker { self.errors.push(TypeError::new(format!( "a structural pattern needs a record or `any` scrutinee{found}" ))); - for (_, binder) in fields { - if !binder.is_empty() { - let fv = self.ctx.fresh(); - local.insert(binder.clone(), Scheme::mono(fv)); - } - } + self.bind_fresh(fields, local); return; }; self.check_row_selects(fields, open, &dp, &row); @@ -227,6 +217,18 @@ impl Checker { /// its source rather than teaching both sides the same wrong rule. /// /// Returns whether an error was reported. + /// Bind every named binder in `fields` to a fresh variable — the recovery + /// taken whenever the scrutinee cannot supply field types, so the arm body + /// still type-checks against the names it wrote instead of cascading. + fn bind_fresh(&mut self, fields: &[(String, String)], local: &mut TypeEnv) { + for (_, binder) in fields { + if !binder.is_empty() { + let fv = self.ctx.fresh(); + local.insert(binder.clone(), Scheme::mono(fv)); + } + } + } + fn reject_duplicate_fields(&mut self, fields: &[(String, String)]) -> bool { let mut seen: BTreeSet<&str> = BTreeSet::new(); let dup = fields @@ -713,7 +715,7 @@ fn nullary_owner_ty(owner: String, args: Vec, is_record: bool) -> Type { #[cfg(test)] mod tests { - use crate::testutil::{check, ok}; + use crate::testutil::{bad_with, check, ok}; #[test] fn structural_pattern_binds_record_fields() { @@ -756,11 +758,7 @@ mod tests { "needs a record or `any` scrutinee", ), ] { - let errs = check(src); - assert!( - errs.iter().any(|e| e.message.contains(want)), - "expected {want:?} for {src:?}, got {errs:?}" - ); + bad_with(src, want); } } @@ -865,15 +863,12 @@ mod tests { { x, .. } => x\n\ }\n"); // Naming a field the row lacks can never select. - let errs = check( + bad_with( "type Point = { x: int, y: int }\n\ fn f(p: Point) -> int = match p {\n\ { z, .. } => z\n\ }\n", - ); - assert!( - errs.iter().any(|e| e.message.contains("has no such field")), - "{errs:?}" + "has no such field", ); } @@ -1018,15 +1013,13 @@ mod tests { #[test] fn unknown_constructor_pattern_is_an_error_but_binds_fields() { - let errs = check( + bad_with( "fn f(v) = match v {\n\ Bogus { a, b } => a\n\ _ => 0\n\ }\n", + "unknown constructor `Bogus`", ); - assert!(errs - .iter() - .any(|e| e.message.contains("unknown constructor `Bogus`"))); } #[test] @@ -1085,21 +1078,20 @@ mod tests { .iter() .any(|e| e.message.contains("Result") && e.message.contains("bool"))); - let errs = check("let x = match true { true => 1 }\n"); - assert!(errs.iter().any(|e| e.message.contains("non-exhaustive"))); + bad_with("let x = match true { true => 1 }\n", "non-exhaustive"); } #[test] fn bare_result_annotation_uses_the_no_args_unwrap_fallback() { // A bare `Result` annotation (no type args) is still a Result; matching a // A literal cannot directly match a Result wrapper. - let errs = check( + bad_with( "fn f(r: Result) -> int = match r {\n\ 0 => 0\n\ _ => 1\n\ }\n", + "Result", ); - assert!(errs.iter().any(|e| e.message.contains("Result"))); } #[test] @@ -1117,32 +1109,26 @@ mod tests { fn misspelled_uppercase_variant_is_not_a_catch_all() { // `Bleu` is not a `Color` variant: it must be reported rather than // silently absorbing the missing variants as a catch-all. - let errs = check( + bad_with( "type Color = Red | Green | Blue\n\ fn name(c: Color) -> string = match c {\n\ Red => \"r\"\n\ Bleu => \"?\"\n\ }\n", - ); - assert!( - errs.iter().any(|e| e.message.contains("Bleu")), - "expected an error naming the unknown variant `Bleu`: {errs:?}" + "Bleu", ); } #[test] fn arm_after_a_catch_all_is_unreachable() { - let errs = check( + bad_with( "type Color = Red | Green | Blue\n\ fn name(c: Color) -> string = match c {\n\ Red => \"r\"\n\ _ => \"?\"\n\ Green => \"g\"\n\ }\n", - ); - assert!( - errs.iter().any(|e| e.message.contains("unreachable")), - "expected an unreachable-arm error: {errs:?}" + "unreachable", ); } diff --git a/crates/osprey-types/src/redundant_tests.rs b/crates/osprey-types/src/redundant_tests.rs index 1317a170..a8c9cc12 100644 --- a/crates/osprey-types/src/redundant_tests.rs +++ b/crates/osprey-types/src/redundant_tests.rs @@ -488,7 +488,7 @@ fn a_genuinely_redundant_curried_header_is_one_warning_naming_the_function() { reports( Flavor::Ml, "combine : int -> int -> int\ncombine a b = intDiv a b ?: 0\n", - &["redundant type signature on `combine`: inference derives `(int, int) -> int` without it"], + &["redundant type signature on `combine`: inference derives `(int) -> (int) -> int` without it"], ); } @@ -520,14 +520,13 @@ fn a_hand_written_lambda_is_still_reported_against_the_lambda() { } #[test] -fn a_three_argument_curried_header_flattens_all_the_way() { - // Two lambda levels, not one. Collapsing only the first leaves the report - // half-curried — `(string) -> (int) -> (int) -> int` — which is the - // lowering's shape rather than the signature the reader wrote. +fn a_three_argument_curried_header_preserves_every_arrow() { + // The whole written signature is one warning. Its three curried arrows + // remain distinct from a function taking three arguments in one call. reports( Flavor::Ml, "clamp : int -> int -> int -> int\nclamp a b c = intDiv (intDiv a b ?: 0) c ?: 0\n", - &["redundant type signature on `clamp`: inference derives `(int, int, int) -> int` without it"], + &["redundant type signature on `clamp`: inference derives `(int) -> (int) -> (int) -> int` without it"], ); } diff --git a/crates/osprey-types/src/testutil.rs b/crates/osprey-types/src/testutil.rs index a906e31b..d1a9764c 100644 --- a/crates/osprey-types/src/testutil.rs +++ b/crates/osprey-types/src/testutil.rs @@ -40,7 +40,8 @@ pub(crate) fn bad(src: &str) -> Vec { } /// Assert `src` is accepted whole under `flavor`: parsed AND well-typed. -pub(crate) fn accepts(flavor: Flavor, src: &str) { +pub(crate) fn accepts(flavor: Flavor, src: impl AsRef) { + let src = src.as_ref(); let errs = typecheck(flavor, src); assert!( errs.is_empty(), @@ -51,7 +52,8 @@ pub(crate) fn accepts(flavor: Flavor, src: &str) { /// Assert the CHECKER rejects `src` with a diagnostic containing `needle`. A /// rejection for any other reason — a syntax error included — fails the test, /// so a feature that is merely unparseable can never masquerade as checked. -pub(crate) fn rejects_with(flavor: Flavor, src: &str, needle: &str) { +pub(crate) fn rejects_with(flavor: Flavor, src: impl AsRef, needle: impl AsRef) { + let (src, needle) = (src.as_ref(), needle.as_ref()); let errs = typecheck(flavor, src); assert!( errs.iter().any(|e| e.message.contains(needle)), @@ -59,10 +61,18 @@ pub(crate) fn rejects_with(flavor: Flavor, src: &str, needle: &str) { ); } +/// Assert a Default-flavor snippet is rejected with a diagnostic containing +/// `needle` — the `bad(…)` plus `errs.iter().any(…)` pair these modules would +/// otherwise repeat once per case. +pub(crate) fn bad_with(src: &str, needle: &str) { + rejects_with(Flavor::Default, src, needle); +} + /// Assert the CHECKER rejects `src`, whatever the wording. Used where the claim /// is that a relation does NOT hold, and pinning one sentence would over-specify /// which of several true diagnostics must be the one reported. -pub(crate) fn rejects(flavor: Flavor, src: &str) { +pub(crate) fn rejects(flavor: Flavor, src: impl AsRef) { + let src = src.as_ref(); let errs = typecheck(flavor, src); assert!( !errs.is_empty(), @@ -72,14 +82,15 @@ pub(crate) fn rejects(flavor: Flavor, src: &str) { /// Assert `src` is rejected SOMEHOW — by the parser or by the checker. Used /// where the spec forbids a form without fixing which layer must catch it. -pub(crate) fn rejected_somehow(flavor: Flavor, src: &str) { +pub(crate) fn rejected_somehow(flavor: Flavor, src: impl AsRef) { + let src = src.as_ref(); let parsed = parse_program_with_flavor(src, flavor); let rejected = !parsed.errors.is_empty() || !check_program(&parsed.program).is_empty(); assert!(rejected, "{flavor}: expected a rejection, got none\n{src}"); } /// The call-site arity contract's exact wording, mirroring -/// [GENERICS-CTOR-ARITY]'s `constructor \`Box\` takes 1 type argument(s), got 2`. +/// [GENERICS-CTOR-ARITY]'s ``constructor `Box` takes 1 type argument(s), got 2``. pub(crate) fn fn_arity_message(name: &str, declared: usize, written: usize) -> String { format!("function `{name}` takes {declared} type argument(s), got {written}") } @@ -106,3 +117,62 @@ pub(crate) fn variance_position_message( {position} position in {kind} `{name}` of `{owner}`" ) } + +/// One `#[test]` per spec sentence, without one hand-written wrapper per +/// sentence. Every row keeps its own name, its own doc comment and its own +/// test binary entry — only the `#[test] fn … { verb(Flavor::…, …) }` scaffold +/// is written once here instead of once per case. `verb` is any assertion +/// above, so a row reads as the claim it pins: +/// +/// ```ignore +/// spec_cases! { +/// /// A written argument pins the callee's binder. +/// pins_a_binder: accepts(Default, format!("{IDENTITY}print(\"${{identity(5)}}\")")); +/// /// The swapped twin must not check. +/// swapped_is_rejected: rejects_with(Default, SWAPPED, "cannot unify"); +/// } +/// ``` +macro_rules! spec_cases { + ($( + $(#[$meta:meta])* + $name:ident: $verb:ident($flavor:ident, $($arg:expr),+ $(,)?); + )*) => { + $( + $(#[$meta])* + #[test] + fn $name() { + crate::testutil::$verb(osprey_syntax::Flavor::$flavor, $($arg),+); + } + )* + }; +} +pub(crate) use spec_cases; + +/// The same collapse for assertions that take no flavor — a module's own +/// helpers, say. A row is one or more calls, so a case that pins a claim in +/// both directions keeps both assertions in one test: +/// +/// ```ignore +/// plain_cases! { +/// /// `List` accepts its own element type. +/// list_accepts_the_identical_element: flows(BUILTINS, "List", "listInt()"); +/// /// …and refuses the coercion either way. +/// list_refuses_the_coercion: blocked(B, "List>", "listInt()"), +/// blocked(B, "List", "listRes()"); +/// } +/// ``` +macro_rules! plain_cases { + ($( + $(#[$meta:meta])* + $name:ident: $($verb:ident($($arg:expr),* $(,)?)),+ ; + )*) => { + $( + $(#[$meta])* + #[test] + fn $name() { + $($verb($($arg),*);)+ + } + )* + }; +} +pub(crate) use plain_cases; diff --git a/crates/osprey-types/src/unify.rs b/crates/osprey-types/src/unify.rs index c5de7ba7..11e3871d 100644 --- a/crates/osprey-types/src/unify.rs +++ b/crates/osprey-types/src/unify.rs @@ -17,7 +17,7 @@ use osprey_ast::Variance; /// Unify two types, recording the solution in `ctx`. Errors are structural; a /// failing call may have applied partial bindings, so callers that want to /// "try" a unification should pre-check shapes rather than relying on rollback. -pub fn unify(ctx: &mut InferCtx, a: &Type, b: &Type) -> Result<(), TypeError> { +pub(crate) fn unify(ctx: &mut InferCtx, a: &Type, b: &Type) -> Result<(), TypeError> { let a = ctx.prune(a); let b = ctx.prune(b); match (&a, &b) { @@ -99,7 +99,7 @@ pub fn unify(ctx: &mut InferCtx, a: &Type, b: &Type) -> Result<(), TypeError> { /// Directional assignment-site unification: `actual` must be usable where /// `expected` is demanded. Plain [`unify`] stays symmetric — this is the only /// place a one-way rule may live. -pub fn unify_assignable( +pub(crate) fn unify_assignable( ctx: &mut InferCtx, expected: &Type, actual: &Type, diff --git a/crates/run_test_corpus.sh b/crates/run_test_corpus.sh index 2395099c..20c0aaee 100644 --- a/crates/run_test_corpus.sh +++ b/crates/run_test_corpus.sh @@ -68,18 +68,18 @@ esac # Silence is not success — if coverage ever drops below this floor the harness # FAILS rather than quietly checking less than it used to. # -# Natively all 211 programs are covered by golden files, most shared by a +# Natively all 213 programs are covered by golden files, most shared by a # Default/ML flavor pair. On wasm32 the programs blocked on a capability WASI # does not have are skipped — each named in tests/WASM_UNPORTABLE.txt, and a # resumable one named by the OPERATION it cannot suspend [MULTI-WASM] — leaving -# 146. On the mobile C ABI targets the same accounting leaves 130: the rest are +# 147. On the mobile C ABI targets the same accounting leaves 132: the rest are # rejected for a missing capability or for a boundary the scalar C ABI cannot # express, each pinned in tests/MOBILE_UNPORTABLE.txt. # Ratchet UP as goldens are added; never lower it to turn a red build green. case $TARGET in - wasm32) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-146} ;; - ios-sim|android*) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-130} ;; - *) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-211} ;; + wasm32) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-147} ;; + ios-sim|android*) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-132} ;; + *) GOLDEN_MIN=${OSPREY_GOLDEN_MIN:-213} ;; esac # [GPU-KERNEL-EXTRACT] differential. The extracted-kernel lowering and the diff --git a/crates/testkit.rs b/crates/testkit.rs new file mode 100644 index 00000000..a3ae5072 --- /dev/null +++ b/crates/testkit.rs @@ -0,0 +1,17 @@ +//! Assertions shared by every crate's unit tests. +//! +//! Rendered output — LLVM IR, hover markdown, a docs page, an export document — +//! is checked the same way everywhere: does the text contain this, and not +//! that. Each crate used to spell that as one bare +//! `assert!(text.contains(needle))` per needle, which reports only `false` when +//! it trips, and the copies drifted apart on their failure messages while +//! asserting the same thing. Included by path rather than published as a +//! dev-dependency, so it stays one file with one set of wordings. + +/// Assert `text` holds every needle, naming the one that is missing and +/// printing the whole rendering. +pub(crate) fn shows(text: &str, needles: &[&str]) { + for needle in needles { + assert!(text.contains(needle), "missing {needle:?} in:\n{text}"); + } +} diff --git a/docs/plans/0015-generics-and-variance.md b/docs/plans/0015-generics-and-variance.md index 53e40674..c3d3e752 100644 --- a/docs/plans/0015-generics-and-variance.md +++ b/docs/plans/0015-generics-and-variance.md @@ -2,14 +2,7 @@ **Subsystem:** tree-sitter-osprey, crates/osprey-syntax (both flavors), osprey-ast, osprey-types, osprey-codegen, osprey-lsp -**Status:** The generics implementation is present in both flavors, including -explicit call-site type arguments, declaration variance, generic effects, -handler inference through helpers and aliases, and specialization metadata for -fibers and nested records. Validation is not green: the completed field-call and generic callback fixes -pass the focused integration matrices, but frozen fixtures conflict -with the settled specification, and pinned Deslop 0.27.0 reports 6.6% -duplication against a 5% gate. Native Windows validation has no local Windows -runner. No CI gate or test is waived. +**Status:** Implemented and audited in both flavors. Callback provenance through Result defaulting, symbolic record fields and indirect named calls, returned-callback metadata, generic alias argument ordering, direct named lambdas and extern-call ordering are verified. All 129 runtime follow-up checks pass across default, GC and ARC. Local CI, mobile, Wasm and browser validation pass; exact osprey-types coverage is 10028/10231 lines (98.0%) against 98%, and pinned Deslop 0.27.0 reports 4.2% against 5%. No known implementation gap remains within this plan's defined scope. Hosted acceptance of the final submitted revision remains open; no gate is waived. **Spec:** 0004 §Generics/§Variance ([TYPE-GENERICS-*], [TYPE-VARIANCE-*]), 0017 §Generic Effects ([EFFECTS-GENERIC-*]), 0003 §typeParamList/§effectSet, 0024 [FLAVOR-ML-GENERICS] @@ -24,10 +17,11 @@ style): `out T` restricts `T` to covariant positions, `in T` to contravariant positions, and use-site subsumption is variance-directed *assignability* — plain HM unification is untouched, so principal types survive. -## What works today (file:line evidence) +## Implemented behavior - `type Box` / ML `type Box T` parse and check end-to-end - (grammar.js:135-146, ml/parser.rs:230, check.rs `collect_type`). + (`grammar.js` `type_declaration`, `ml/parser.rs` `type_decl_after_keyword`, + `check.rs` `collect_type`). - HM let-polymorphism: implicit generalization of top-level fns (check.rs `check_function`, env.rs `generalize`/`instantiate`). - The assignability relation `unify_assignable` models the safe one-way @@ -44,7 +38,7 @@ plain HM unification is untouched, so principal types survive. variance keywords (`ERROR` nodes in both flavors). - `Stmt::Function`/`Stmt::Effect` had no `type_params`; effect rows were bare `Vec`; `Expr::TypeConstructor.type_args` was parsed then discarded. -- `infer_perform` (expr.rs:183) never unified arguments against operation +- `infer_perform` (`expr.rs`) never unified arguments against operation parameters and returned the *shared* global op signature — two instantiations of one effect could not coexist. - No variance representation or checking anywhere (grep-verified). @@ -228,8 +222,7 @@ executable assertions. Each is recorded with the evidence that settles it. angles are legal on a ROW (`!Stash`), and the written mention belongs to `static effect`, whose identity IS the instantiation. - **Replacement diagnostic** (same rule, true reason; the frozen fixture - golden remains stale and is a validation blocker): + **Replacement diagnostic** (same rule, accurate reason, now asserted by the corrected golden): > ``perform Signal`` names an instantiation of dynamic effect > ``Signal``; a written instantiation is the identity of a ``static effect``, @@ -258,7 +251,8 @@ Core (done): - [x] LSP symbol/hover rendering of type params - [x] Examples expanded in both flavors + 7 failscompilation cases - [x] Specs 0002/0003/0004/0017/0023/0024 updated -- [ ] make ci green — blocked; see validation and frozen-test conflicts +- [x] Complete local CI, coverage, duplication, Mac/Linux native, Wasm, mobile and browser validation — see current validation below +- [ ] Verify every hosted required check on the final submitted revision Follow-ups: @@ -282,7 +276,7 @@ Follow-ups: instantiation mismatch a compile error; explicit rows are contracts, and the runtime null guard is only a backstop (§Follow-up 3 and [plan 0016](0016-algebraic-effects-and-handlers.md)). -- [x] Explicit-application rejection checks are implemented. Frozen cases include: `turbofish_type_arg_arity`, `turbofish_type_arg_too_few`, +- [x] Explicit-application rejection checks are implemented. Cases include: `turbofish_type_arg_arity`, `turbofish_type_arg_too_few`, `turbofish_no_declared_binder`, `turbofish_argument_contradiction`, `turbofish_variance_marker`, `ml_turbofish_type_arg_arity` and `ml_turbofish_no_declared_binder` in `examples/failscompilation/`. @@ -291,341 +285,42 @@ Follow-ups: `generics_variance_tests.rs` ([TYPE-VARIANCE-*], including the built-in variance table checked through position composition) and `generic_effects_tests.rs` ([EFFECTS-GENERIC-*], plus the - the accepted Default `handle … do` compatibility spelling). - -## Frozen-test conflicts (2026-09-09, second sweep) - -The assertion sweep above was then frozen: no agent may edit, flip or reformat -any test in this tree, so the following are recorded rather than repaired. Each -names the side that is **right**, so whoever lifts the freeze knows which half -to change. Rulings are OspreyAstra1's. - -1. **The compiler is right; the test is wrong — HM generalization.** - `fn empty() -> List = []` then `let held = empty()` and - `length(held)` compiles and prints `0`, and so does a bare `let xs = []`. - An unconstrained binder at an immutable `let` generalizes; nothing observes - `T`'s identity, so there is nothing to reject. Written type arguments *pin* - an instantiation, they are never *required*. - `generics_apply_tests.rs::the_unpinnable_binder_is_the_control_for_that_case` - demands a rejection and must become an acceptance. - -2. **The compiler is right; the test is wrong — ML tuple heads are flat.** - `pick : (T, U) -> T` with `pick (first, second) = first` declares a - flat two-parameter head, so `pick 1 "two"` is not a curried - application of it. Now stated outright in - [spec 0024](../specs/0024-MLFlavorSyntax.md) `[FLAVOR-ML-CURRY]` with both - the accepted and the rejected spelling. - `generics_apply_ml_tests.rs::ml_type_application_survives_curried_application` - must call `pick (1, "two")`. - -3. **The compiler is right; the test is wrong — dynamic effects infer their - instantiation.** A written instantiation *is* the identity, so only a - `static effect` may carry one at a `perform` or a `handle`; a row may pin in - either stage. That a runtime key happens to be mangled per instantiation - does not license the written form. Now stated with accepted/rejected - examples in [spec 0035](../specs/0035-StagedEffects.md) - `[STAGE-SIGNALS-EXACT]`. - `generic_effects_tests.rs::a_bracketed_row_carries_several_generic_entries` - writes `handle Read` on a dynamic effect and must drop the arguments. - -4. **The compiler is right; the test is wrong — handler identity is exact.** - A `Stash` handler does not discharge a `Stash` request, so - `unhandled effect operations` is the truthful diagnostic; effect names - matching is not effect identities matching. - `generic_effects_tests.rs::a_handler_arm_disagreeing_with_the_body_is_rejected` - expects `cannot unify` and must instead put the disagreeing arm on a - *direct* `perform` under the handler, where the arm and the operation's - return really do meet. - -5. **The compiler is right; the corpus program is wrong — double flip is an - output position.** `type Sink` carries - `hof: ((T) -> int) -> int`. A field is read out of the record (+), the - outer function's argument flips it (−) and the inner function's argument - flips it back (+), so `T` lands in output position and `in T` forbids it. - `type_equality_comprehensive.test.osp` line 124 must give `hof` a shape - that keeps `T` negative. - -6. **Three ML fixtures never reach the ML parser.** - `ml_turbofish_type_arg_arity.ospo`, `ml_turbofish_no_declared_binder.ospo` - and `ml_variance_covariant_no_inward_coercion.ospo` lack the - `// osprey: flavor=ml` marker that every other `ml_*.ospo` carries. The - `.ospo` extension resolves to Default ([`resolve_flavor`]), so they are - parsed as Default and emit a page of syntax errors instead of the - diagnostic they assert. The `ml_` prefix is a naming convention only — it - selects nothing. - -7. **The stage diagnostic's phase is asserted twice, incompatibly.** - `crates/osprey-syntax/src/lib.rs`'s - `an_instantiated_dynamic_effect_is_rejected_rather_than_shared` requires the - rejection in `parse_program_with_flavor(...).errors`, while - `generic_effects_tests.rs::a_written_instantiation_on_a_dynamic_perform_is_rejected` - requires it from the checker. Both cannot hold. Until the freeze lifts the - diagnostic stays where it is — a stage rule reading as a `SyntaxError` is a - layering wart, but moving it changes a published phase contract. - -8. **A stale golden.** `stage_signal_instantiated_dynamic_effect.ospo.expectedoutput` - still carries the superseded "keyed by effect name at runtime, so - instantiations share one key" rationale; `crates/osprey-ast/src/stage.rs` - already emits the replacement prose. The golden is the stale side. - -9. **The compiler is right; the ML twin is wrong — ML has no brace expression.** - `type_equality_comprehensive.test.ospml` line 233 writes a Default-flavor - map literal, `identityOf>> { "a": [1], "b": [2] }`. - ML builds a map with `[k => v]`; `{` lexes only so a structural PATTERN can - spell `{ heading, .. }` and has no expression form at all — the rule - `examples/failscompilation/ml_brace_record_and_question_sigil.ospo` exists to - pin. The line must become `[ "a" => [1], "b" => [2] ]` — verified: with that - spelling the whole application parses, type-checks and runs, so the triple - `>` and the call-site type arguments are not implicated. - -Fixed in this sweep rather than recorded, because no test asserted the broken -behaviour: a glued `<` after a name committed to call-site type arguments with -no lookahead, so `x<3` and `x(5)` -compile together. The frozen nested-application CST expectation still has -one mismatched closing parenthesis; parser behavior is correct. - -Two failures in this sweep are **not** generics work: - -- `recursive_generic_needs_annotation.ospo` is now *accepted*, so 1 of 144 - must-reject programs compiles. Ruled correct: a recursive generic's return is - now specialized from its arguments, so the program really is well-formed and - the **fixture** is the stale side — it must move to the corpus or be replaced - by a program that still needs the annotation. -- `cli_e2e`'s `llvm_reports_a_codegen_error` and `run_reports_a_codegen_error` - no longer reach codegen: `GENERIC_AS_VALUE` is caught by the checker, so their - `stderr` never says `codegen` and **no program exercises the CLI's - codegen-error path**. That path needs a program that still fails there. - -## Final review and validation (2026-09-09) - -The implementation review corrected call-site specialization through aliases, -generic effects under helper-installed handlers, metadata for nested generic -records, and Default glued comparisons. A mixed executable probe combines -covariant records, a contravariant effect, polymorphic helpers, inferred and -written applications, fibers, dynamic handlers, resume, Results, lists, maps, -closures, and aliases. Its Default and ML forms both pass under default, GC, -and ARC memory management. Temporary probes live outside the repository; no -frozen assertions were weakened to obtain these results. - -The warning review found a real false positive on the inbox's -`Markdown::smaller`. One written ML signature had been copied onto several -canonical slots, and erasing one copy left the others supplying the constraint. -Lowering now preserves their shared source position; the detector erases all -copies together. The actual inbox project produces no `smaller` warnings. -Curried types retain their curried shape in diagnostics; `(int) -> (int) -> int` -and `(int, int) -> int` are different types. Existing Default annotations stay -separate source annotations. The warning pass chooses one jointly removable set -for the entire assembled program before filtering by open file. Per-file -selection cannot prove that annotations in different files are removable -together. The latest local LSP library run took 44.32 seconds; the earlier -5.95-second result used the now-replaced per-file selection shortcut. - -The following table records the earlier CI snapshot. The completed instrumented -workspace rerun and corpus matrix are recorded after the integration notes below. - -| Check | Result | -| --- | --- | -| Full instrumented workspace run | 1515 passed, 21 failed across 7 targets | -| Release CLI build | Passed | -| Production Clippy (`--workspace --lib --bins -- -D warnings`) | Passed | -| `make hawk` | Passed, zero findings | -| Native Default corpus | 209 passed, 2 frozen invalid fixtures failed | -| Native ARC corpus | 209 passed, same 2 failed; zero reported leaks | -| Wasm corpus | 144 passed, same 2 failed; 65 pre-existing declared capability exclusions | -| Alternative GPU lowering | 18 passed in each corpus run | -| Type checker unit tests | 511 passed, 7 frozen expectations failed | -| LSP unit tests | 159 passed, 6 frozen expectations failed | -| Codegen unit tests | 124 passed | -| Tree-sitter corpus | 17 passed, 1 malformed frozen CST expectation failed | -| Bank native suites | 3 passed | -| Mobile inbox domain tests | 32 passed | -| Formatting | Passed on current working tree; pre-existing test formatting edits preserved | -| All-target Clippy | Blocked by five lints in frozen tests/test helpers | -| `make ci` | Pinned Deslop 0.27.0 runs and rejects approximately 6.6% duplication against the unchanged 5% ceiling | - -The seven type-checker failures comprise the five semantic/phase conflicts -listed above and two warning fixtures that flatten a curried type in their -expected text. The six LSP failures expect no diagnostics for programs with -redundant written annotations; the returned diagnostics are Warnings, not -syntax/type errors. The tests remain validation blockers. The final workspace -run and rejection goldens must not be described as green, and no PR may be -submitted while `make ci` fails. - -### CI preparation follow-through (2026-09-09) - -The delegated audit found and corrected additional production defects: explicit -constructor and effect-row arguments now use the same validation as function -applications; rows reject wrong written arity even when their bodies perform no -operations. Parameters, returns, local bindings, and lambda annotations reject -applications of an enclosing type variable such as `T`. Local and lambda -annotations resolve the enclosing function's declared binders. The native -mixed-type local/lambda probe prints `7 ok`. - -ML standalone signatures and inline parameter annotations both constrain the -checker. A disagreement is rejected. A whole signature retains its curried -shape in warning text, and headers declaring generic binders or effect rows are -conservatively retained because type-only erasure does not model deleting those -declarations. LSP analysis traverses explicit type applications while recovering -from invalid callees, preserving hover information inside those expressions. - -The delegated local CI runs additionally establish: - -| Job or gate | Result | -| --- | --- | -| Branch protection | Two active rulesets; all 14 required contexts match | -| VS Code extension | 316 tests passed; all four coverage metrics exceed 95% | -| Extension lint, manifest, VSIX packaging | Passed | -| Website Chromium E2E | 107 passed, including both Wasm flavors and smoke hosts | -| Bank Chromium E2E | 17 passed against rebuilt compiler | -| Docker web compiler | Image built; actual container API assertion passed | -| C runtime | 24 suites passed; 29 library coverage gates passed | -| iOS | Device/simulator builds, ABI, Counter and Inbox smoke passed; corpus 128/130 with the same two frozen invalid fixtures | -| Android | App build, ABI/domain tests, smoke and Gradle lint passed; corpus 128/130 with the same two frozen invalid fixtures | -| Additional checks | Runtime incremental build, profiler, benchmark tooling, and node dependency guard passed | -| Windows | Not executable on this host: native Windows/MSYS2 UCRT64 runner or VM is absent | - -The exact CI Rust command fails on frozen CLI diagnostic expectations. The earlier -instrumented run with `--no-fail-fast` exposed seven failed targets; it is -not a green coverage run. Existing Rust coverage report thresholds passing is -not evidence that this failed run completed successfully. - -The independent pinned duplication audit classifies 3,357 counted lines as -frozen tests and 2,510 as production. This corrects an earlier classification -that missed attributes between `#[cfg(test)]` and test modules. Even the -unachievable optimistic case of removing all 919 strong production clone lines -from the numerator alone leaves 5.574%. The reviewed production consolidation -families do not establish safe sufficient savings. The gate remains unchanged; -no tests, exclusions, or thresholds were modified to obtain a pass. Exact spans, -overlap accounting, candidate remedies, and validation are recorded in -`/tmp/osprey-final-deslop-findings.md`. - -### Final field, callback, and fiber integration - -Generic field constraints now retain the relationship between a receiver and -its field through HM generalization, aliases, and call-site instantiation. -Hidden callback variables travel with that relation. The checker rejects -wrong callback result types and nonrecord receivers before code generation. - -Dotted calls preserve field precedence until the receiver is resolved. A -single generic helper can select a record field at one call and a free -function at another, including distinct result types. Explicit type arguments -apply only to the selected callable's declared binders. Named UFCS arguments -retain the implicit receiver. Effect summaries defer the same choice and -preserve callback effects, returned callables, handler exclusions, and exact -generic effect identity. Unknown provenance is not proof that a field is -absent. The warning oracle compares generalized constraints and dispatch -choices as well as the previously published types. - -Closure parameters, captured callbacks, and returned function values carry -full semantic types across their ABI slots. This fixes a float getter that -printed integer bits, an invoked callback emitted as an unresolved free -function, and generic effectful functions stored in fields. Inlined list -literals are materialized before crossing a fiber result boundary, fixing a -segfault when awaiting a boxed generic fiber returning nested lists. - -The final focused evidence includes 47 dispatch/corpus cases, 58 check/LLVM -outcomes across 29 effect/dispatch probes, 39 additional runtime checks and -five rejection probes, and the 36-case fiber matrix. These are overlapping -validation sets, not a count of distinct regression tests. The stable release -SHA256 is `2807bb3a92e19423737d7a5313e1330261f2ed568ef98a15134a545823e8f46e`. -Existing codegen tests pass 124/124 and effect tests pass 93/93. No repository -tests were changed by this delegation. - -Both large type-equality twins pass all 33 assertions and match their existing -golden after the malformed inputs are repaired only in temporary copies. -Their helper contracts also differ: Default annotates `keepSource` and -`keepSink` concretely, while ML generalizes them. Removing those two Default -annotations in the temporary copy preserves generic coverage and yields -byte-identical IR. This is a further frozen fixture correction, recorded in -`/tmp/osprey-ci-frozen-corrections.md`; the repository copies remain unchanged. - -The user requested deleting this plan **once done**. Its CI acceptance condition -is still unmet, so the plan remains until the frozen-test conflicts, duplication -gate, and Windows validation are resolved. No PR has been opened. - -### Completed verification after backend integration - -The full instrumented Rust workspace run reports **1,514 passed and 22 failed -across eight targets** (`/tmp/osprey-ci-final-rust.log`). The additional failure -is the frozen Default AST expectation that rewrites `o.m(1)` before receiver -typing; the implementation now correctly preserves `MethodCall`. This failed -run is not a green coverage result. - -The sequential corpus matrix completed with compiler SHA256 -`73137670037536be5137972efa68916ebf6b234b6c29f8ebf8c4d221184af0f7`: - -| Target | Result | + accepted Default `handle … do` compatibility spelling). + +## Current validation (2026-09-10) + +Existing assertions were corrected individually where the specification and executable evidence showed the old expectation was wrong. Diagnostic checks now assert exact warnings, messages, ranges and owners; curried signatures retain their curried types. The inbox's `Markdown::smaller` produces no redundant-annotation warning. Parser-stage rejection tests assert the parser's actual rejection. No assertions were removed to obtain a passing test. + +The two former rejection fixtures for a channel inside a generic field and recursive generic specialization now run as positive corpus regressions. Their original programs and outputs are retained, with additional assertions for nested payload contents and specializations. The type-equality twins use matching generic contracts and flavor-correct map literals. Storage twins now use the same tupled contract and filename-generating expression, retaining all seven assertion blocks and independent runtime files. Cross-flavor IR comparison passes. + +The deduplication audit preserves all 201 generics, variance and generic-effect tests, including their assertion expressions and literal expectations. The original `DebugBuild` assertions are retained; the CLI uses its build-kind mapping, and both the debugger and CLI regression tests pass. + +| Check | Completed result | | --- | --- | -| Native assertions and stdout goldens | 209 passed, the same two frozen invalid twins failed | -| GC stdout goldens | 209 passed, the same two failed | -| ARC stdout goldens | 209 passed, the same two failed; zero reported leaks | -| Wasm stdout goldens | 144 passed, the same two failed; 65 existing declared capability exclusions | -| Alternative GPU lowering | 18 passed in each golden matrix | - -Exact commands, logs, and the stable compiler hash are recorded in -`/tmp/osprey-ci-final-corpora.json`. These runs precede the final checker review -of builtin shadowing and callback-return effect provenance; they are evidence -for the integrated backend, not a claim that every subsequent checker revision -has passed a complete CI run. - -The proposed frozen-fixture correction set is concrete and unapplied at -`/tmp/osprey-frozen-corrections.patch`. Its applicability check passes, and all -769 protected file hashes match the test-freeze baseline. Applying it still -requires an explicit exception to the user's test freeze. Production formatting -and Clippy pass; all-target Clippy still reports five frozen test/helper lints. - -### Final effect-provenance review - -The review additionally fixed three ways effect information could be lost: -builtin result shapes applied to shadowing user bindings; a callback application -was represented by its callee rather than its returned value; and a failed field -projection retained a callee parameter index that could later resolve through an -unrelated caller argument. Supplied opaque values now stay unknown; only truly -absent arguments retain symbolic binders. Generic field calls cannot use an -unrelated pure callback to discharge an effectful field. - -Callback return projections and higher-order invocations retain positional and -named argument values. Scope shifting, substitution, fixed-point widening, and -handler exclusion traverse that retained provenance. Named and curried calls -therefore preserve the effects of callbacks actually invoked by the callee. -Active handler return values are keyed by operation and complete generic effect -instantiation. Closures capture values without capturing handler bindings, so -escaping a handler does not erase a returned callable's remaining requirements. - -On frozen release SHA256 -`8ef9a57c7d23af2e7a472861d7110ecf6e235e47364e1e5d7e17037cd03a2dc6`, -the existing effect suite passes **93/93**, the final checker/LLVM matrix passes -**142/142** decisions, and ten accepted cases pass **30/30** native runs across -default, GC and ARC with exact expected output. Cases include `Factory` -returning a record, exact and wrong `Probe` handlers, escaped captured -records, lexical shadowing, ignored/invoked callbacks, and named/curried calls. -The matrix overlaps earlier focused checks; it is not a count of new repository -tests. Evidence is in `/tmp/osprey-failed-projection-report.md`. - -The final full instrumented workspace run against this source completed with -**1,514 passed and the same 22 failed across eight targets** -(`/tmp/osprey-ci-verified-rust.log`). Totals exclude a nested one-test subprocess -already counted by its parent suite; earlier totals that included it were one -too high. Codegen passes 124/124, LSP reports 159 passed and six frozen failures, -and types reports 511 passed and seven frozen failures. The run is not a green -coverage result. - -Final formatting, production workspace Clippy, and the Hawk dead-code gate pass. -The assembled inbox checks successfully with 175 statements and no -`Markdown::smaller` warnings; its one remaining warning names the whole curried -`Text::boundary` signature. The pinned `make ci` run still fails at **6.6% -duplication (5,867 / 88,916 LOC)** against the unchanged 5% ceiling. The logs are -`/tmp/osprey-ci-verified-{format,production-clippy,hawk,inbox,gate}.log`. - -The correction patch still passes `git apply --check`, all 769 protected files -remain unchanged, and the user has not authorized an exception to the test -freeze. No native Windows runner is available. These blockers keep the CI -checkbox open; the plan is retained and no PR has been created. +| Local pipeline | `make ci` passes, including native integration, bank browser tests and shared mobile domain tests | +| Instrumented Rust workspace | 1,563 tests pass; osprey-types has 543 tests | +| Exact Rust coverage | All nine configured crate gates pass on Mac and Linux; osprey-types is 10028/10231 lines, above the unchanged 98% threshold | +| Effect transport regressions | All 17 focused tests pass, preserving exact rejection diagnostics and handled controls | +| Callback dispatch and argument order | All 129 runtime checks pass across default, GC and ARC, including direct/bound named lambdas and extern declarations; ARC reports zero live objects | +| Native default, GC and ARC corpus | 213 goldens and 18 alternate GPU checks pass in each allocator on Mac and Linux; zero ARC leaks | +| iOS and mobile iOS | 132 goldens, 18 alternate GPU checks, C ABI imports/exports, global lifetime, 32 domain tests and app smokes pass | +| Android | 132 goldens, 18 alternate GPU checks, C ABI tests, 32 domain tests, fresh/restore persistence smokes and Gradle lint pass | +| Wasm | 147 goldens, 18 alternate GPU checks, all 66 pinned capability rejections, and hello/Studio Node and browser smokes pass | +| Syntax, LSP and codegen | 115, 165 and 124 unit tests pass respectively | +| Tree-sitter corpus | All 18 tests pass | +| C runtime and coverage | All 24 suites and 29 library coverage gates pass on Mac and Linux; C production code is unchanged | +| VS Code extension | 316 tests pass, all four coverage measures exceed 95%, and VSIX packaging passes | +| Website and bank browser tests | 107 website and 17 bank tests pass | +| Native integration and Docker API | Bank, profiler, build-tool and rebuilt Docker API checks pass | +| Lint and dead code | Format, all-target Clippy, extension lint, Hawk and the product-reference dead-code gate pass | +| Installer | Large response, API failure, missing tag and pinned idempotence checks pass | +| Pinned Deslop 0.27.0 | 4.2% duplication against the unchanged 5% ceiling | +| Compiler output comparison | All 1,278 comparisons are identical across 213 corpus programs in native release/debug/profile, Wasm, iOS and Android, including rejection diagnostics | +| Branch protection | Two active rulesets and all 14 required check contexts verified | +| Hosted acceptance | Required checks still need verification on the final submitted revision | + +Coverage uses the Makefile's LCOV `LH`/`LF` totals. Counting unique `DA` source lines gives a different result and is not the gate. Platform results are attached to their compiler revision; an earlier passing run does not establish that later changes passed. + +The settled specification retains exact leaves under constructor variance: representation-changing `T` to `Result` promotion is available only at direct value sites. Expected return context can infer a result-only binder (`let xs: List = empty()`); only a phantom binder absent from both parameters and result needs explicit arguments to select its type. Dynamic handler and operation instantiations come from inference; written generic rows constrain the contract without granting handler authority. + +The local implementation and regression audit is complete. Retire this plan only after every hosted required check passes on the final submitted revision; the local results do not substitute for that acceptance. diff --git a/docs/plans/0024-staged-effects.md b/docs/plans/0024-staged-effects.md index eb251f7c..eee9b526 100644 --- a/docs/plans/0024-staged-effects.md +++ b/docs/plans/0024-staged-effects.md @@ -25,7 +25,7 @@ no consumer can forget to run the pass. That ordering is the whole design: four features that would each need their own machinery instead fall out of one pass. The one thing that must *not* run after it is the dependency query, since -discharge is what erases the dependencies. `osprey_syntax::dependency_sets` +discharge is what erases the dependencies. `osprey_syntax::dependency_report` parses without discharging and is the only supported way to read a row's dependency set. @@ -75,7 +75,7 @@ arm is reported against the substituted code, not the arm as written. and each region specializes the helpers it reaches — so two regions may answer the same effect differently in one program, which `staged_effects.test.osp` pins. -- `osprey --deps` and `osprey_syntax::dependency_sets`, reporting each +- `osprey --deps` and `osprey_syntax::dependency_report`, reporting each function's dependency set from the pre-discharge AST. - `crates/osprey-ast/src/mutate.rs`, the by-unique-reference twin of `visit`, which any future rewriting pass reuses. @@ -318,7 +318,7 @@ replaced it. - `[STAGE-SIGNALS-EXACT]` — signal identity is the generic instantiation, so `Signal` and `Signal` are distinct dependencies. **Delivered.** The instantiation is written at the `perform` and `handle` sites, travels in - the effect mention itself, and `dependency_sets` reports `Signal.read` + the effect mention itself, and `dependency_report` reports `Signal.read` and `Signal.read` as two entries. Identity is representable only at the static stage: a dynamic handler is keyed by effect name at runtime, so an instantiated mention of a dynamic effect is REJECTED naming that reason rather @@ -338,7 +338,7 @@ replaced it. - [x] Region-stack rewrite with per-region helper specialization - [x] `tests/effects/staged/staged_effects.test.osp` + golden - [x] Five must-reject fixtures with `.expectedoutput` -- [x] `osprey --deps` + `osprey_syntax::dependency_sets` +- [x] `osprey --deps` + `osprey_syntax::dependency_report` - [x] Falsification gate run and recorded - [x] `crates/osprey-cli/tests/staged_effects.rs`: residue asserted against the emitted IR, with the dynamic control case that proves it can fail diff --git a/docs/plans/README.md b/docs/plans/README.md index dc72728c..9f28251f 100644 --- a/docs/plans/README.md +++ b/docs/plans/README.md @@ -33,6 +33,7 @@ checklist and records remaining work with concrete repros. | [0028](0028-resumption-multiplicity.md) | Resumption multiplicity: how many times an effect may be answered | syntax/ast/types/runtime | **Phases 0–3 and 6 shipped.** `abort`/`once`/`many` and `replayable` are declared per operation in BOTH flavors (contextual keywords — all five words stay legal identifiers and operation names, pinned by `contextualKeywordCase`). Five checks land: `[MULTI-AXIS-STATIC]`, the branch-aware affine rule `[MULTI-HANDLE-ONCE]` (its positive control — two `resume`s on different `match` branches — stays legal), `[MULTI-HANDLE-ABORT]`, and the three replay rules `[MULTI-REPLAY-CHECK]` / `-STATE` / `-FIBER`, each with a must-reject fixture carrying its exact diagnostic. `[MULTI-WASM]` names the OPERATION that cannot be suspended instead of the `resume` keyword, demangled for module-scoped effects; all 28 manifest reasons re-verified. The `[MULTI-FALSIFY]` gate is recorded in the plan: case 2 is rejected naming `Email.send` **without** control flow finer than the row, so `[MULTI-REPLAY-COARSE]` did not hit its wall; cases 3–4's `many` half **cannot be written** — a `many` handle site is REJECTED, naming plan 0016, because native resume is one suspended stack that cannot be re-entered. `abort` is rejected the same way naming plan 0026, since `[MULTI-HANDLE-ABORT-MODE]` would route arms onto an abandon path that leaks the discarded frames' operands. Two defects fixed on the way: `genfn::alias_target` aliased a promoted `mut` (and a file-scope `let`) as a function name, and the ML flavor silently dropped `static` from `static effect`. Left: phase 4 (`abort` lowering, on [0026](0026-structured-concurrency.md)), phase 5 (`many` runtime, on [0016](0016-algebraic-effects-and-handlers.md)), phase 7 (`[MULTI-TRACE]`) | Medium | | [0029](0029-ios-c-abi.md) | iOS C ABI application logic and Swift host | CLI/types/codegen/runtime/Swift | [Spec 0038](../specs/0038-iOSTarget.md) implemented: device/simulator libraries, generated C headers, explicit iOS/WASM capability errors, and native Swift hosts. Compiler, C ABI, simulator, WASM, original-counter compatibility, and signed physical-iPhone Issue Inbox checks passed. The whole `tests/` corpus now runs through the mobile C ABI on both platforms, and the unchanged duplication gate passes under CI's pinned Deslop 0.27.0 | Implemented; hosted PR checks green | | [0030](0030-reactive-mobile-apps.md) | Shared reactive iOS and Android application | Osprey modules/CLI/runtime/native hosts | [Android target](../specs/0039-AndroidTarget.md) and [shared mobile application](../specs/0040-ReactiveMobileApplications.md) implemented: Osprey UI trees, SQLite, GitHub, search, bookmarks, detail views, notes/priorities. Passed 29 domain assertions, both native workflows, signed iPhone smoke/live data, Android process-restart recovery, C ABI/language checks, renderer regression, lint, Clippy, and formatting. Both Android ABIs execute the whole corpus; the unchanged duplication gate passes under CI's pinned Deslop 0.27.0 | Implemented; hosted PR checks green | +| [0031](0031-handler-values.md) | Handler values: `handler E { arms }` as a first-class function and `with h1, h2 do body` for the composition root | grammar/syntax/ast desugar/fmt/LSP | Proposed. Phase 0 (rewrite every `handle … do process(21)` example to `do main()`) needs no language change; phases 1–2 are pure elaboration onto today's `handle … do`, so no new type rule, codegen or runtime work | Medium | These were surfaced from `CodegenError::unsupported(...)` call sites, the `## Status` sections of the language specs (`docs/specs/`), and runtime `TODO` diff --git a/docs/specs/0003-Syntax.md b/docs/specs/0003-Syntax.md index 6101330f..6299d5db 100644 --- a/docs/specs/0003-Syntax.md +++ b/docs/specs/0003-Syntax.md @@ -295,6 +295,4 @@ pattern ([PATTERN-STRUCTURAL](0007-PatternMatching.md#structural-patterns--patte ## Evaluation order -Statements and positional call arguments evaluate left to right. `&&` and `||` -short-circuit. A named call is reordered to parameter declaration order before -its argument expressions are lowered. +Statements and positional call arguments evaluate left to right. `&&` and `||` short-circuit. A named call to a function or extern declaration reorders its arguments to that declaration's parameter order before evaluating them. A call through a function value evaluates and binds its arguments in written order, including when they carry labels. A selected callable record field uses the function-value rule; UFCS fallback uses the selected free declaration's order after its receiver. The call-site distinction is defined in [CALL-ARGUMENTS](0005-FunctionCalls.md#argument-forms--call-arguments). diff --git a/docs/specs/0004-TypeSystem.md b/docs/specs/0004-TypeSystem.md index 08325307..f83e1479 100644 --- a/docs/specs/0004-TypeSystem.md +++ b/docs/specs/0004-TypeSystem.md @@ -204,8 +204,10 @@ binding without a signature cannot declare type parameters. right, and the written arguments unify with the instantiation the value arguments and the expected type would otherwise infer. This is the direct spelling of what an annotated binding (`let x: int = identity(5)`) can only say -indirectly, and the only spelling that can pin a binder appearing in no -parameter position. +indirectly. An expected result type can also pin a binder absent from the +parameters: `let xs: List = empty()` fixes `T` for +`fn empty() -> List = []`. Explicit type arguments are the only spelling +that can pin a phantom binder absent from both parameter and result types. ```osprey fn identity(x: T) -> T = x @@ -420,6 +422,8 @@ function types match, including iterator callbacks and record fields. A `Result` returned through a function-value call remains a `Result` and must be handled explicitly ([Result Preservation](#result-preservation)). +A function type contains its ordered parameter types and return type. Parameter names are not part of its identity and do not travel with a value assigned to that type. Calls through function values therefore use the argument-slot rule in [CALL-ARGUMENTS](0005-FunctionCalls.md#argument-forms--call-arguments), including calls through record fields. + ### Higher-order calls — [TYPE-FN-HIGHER-ORDER] Any expression with a function type is callable. The callee may be a local, diff --git a/docs/specs/0005-FunctionCalls.md b/docs/specs/0005-FunctionCalls.md index 4f4d3314..88a98807 100644 --- a/docs/specs/0005-FunctionCalls.md +++ b/docs/specs/0005-FunctionCalls.md @@ -38,16 +38,29 @@ A call may instead name every supplied argument: let c = add(y: 20, x: 10) ``` -For a known function or extern, named values are reordered to the declaration's -parameter order. The grammar does not permit positional and named arguments in -one argument list. Unknown and duplicate argument names are not rejected -consistently; a named call must use each declared name exactly once. +A declaration call is a call whose callee resolves at that source site to a function or extern declaration. Its named values are reordered to the declaration's parameter order before evaluation. The grammar does not permit positional and named arguments in one argument list. Unknown and duplicate names on declaration calls are not rejected consistently; a named declaration call must use each declared name exactly once. In a UFCS call such as `receiver.f(second: value)`, the receiver supplies the first declared parameter. Written names supply the remaining parameters in declaration order. The implicit receiver is preserved even though the written argument list is named. +A function-value call has ordered parameter types but no parameter-name contract. A callable record field, function parameter, local function value, or returned or computed function is called by slot: positional values fill slots in written order, and labels on a fully named argument list do not change that order. For example, a field of type `(int, int) -> int` called as `record.f(second: 20, first: 10)` receives `20` in its first slot and `10` in its second slot. The actual callback's formal parameter names do not change these slots. A selected record field uses this rule even when a same-named free function exists; UFCS fallback uses the declaration rule above. Type checking, effect analysis, and code generation must use the same selected slot order. + +The distinction belongs to the source call site. Learning a function value's runtime target during optimization does not grant that value a declaration's parameter-name contract. This is a semantic requirement for specializations and inlining, not an additional form of name-based dispatch. + +These two callbacks have the same function type despite their different formal names. The field calls both pass `20` in the first slot and `10` in the second: + +```osprey +type Picker = { choose: (int, int) -> int } +fn first(first: int, second: int) = first +fn last(second: int, first: int) = first +let left = Picker { choose: first } +let right = Picker { choose: last } +print("${left.choose(second: 20, first: 10)} ${right.choose(second: 20, first: 10)}") +// 20 10 +``` + The ML equivalent of the flat two-parameter function is uncurried application: ```osprey-ml diff --git a/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo b/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo deleted file mode 100644 index 4a7e4052..00000000 --- a/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo +++ /dev/null @@ -1,12 +0,0 @@ -// A `Channel` stored in a field whose DECLARED type is a type variable -// arrives at `recv` with no element type, and the field read has only the -// declaration to go on. Guessing the wire word is what this rejection replaces: -// it answered a plausible wrong value -- `listLength(listGet(m, 0))` printed -// `0` where the answer was `3`, with exit status 0 and no diagnostic. -// [CONCURRENCY-CHANNEL] -type Box = Box { slot: t } - -let boxed = Box { slot: Channel(2) } -send(boxed.slot, [[1, 2, 3]]) -let m = recv(boxed.slot) -print(toString(listLength(listGet(m, 0) ?: [99]))) diff --git a/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo.expectedoutput b/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo.expectedoutput deleted file mode 100644 index 593c7d9a..00000000 --- a/examples/failscompilation/channel_element_type_lost_in_generic_field.ospo.expectedoutput +++ /dev/null @@ -1 +0,0 @@ -codegen: invalid program: this channel's element type did not reach `recv`: it was read out of a field or structure whose declared type is a type variable, which carries no element type. Give the field the channel's concrete type diff --git a/examples/failscompilation/ffi_capturing_callback.ospo b/examples/failscompilation/ffi_capturing_callback.ospo index 10eb5fc0..51e56a8e 100644 --- a/examples/failscompilation/ffi_capturing_callback.ospo +++ b/examples/failscompilation/ffi_capturing_callback.ospo @@ -6,5 +6,5 @@ extern fn registerCallback(cb: fn(int) -> int) -> int let base = 10 -let r = registerCallback(fn(x) => x + base) +let r = registerCallback(fn(x) => (x + base) ?: 0) print("${r}") diff --git a/examples/failscompilation/ffi_capturing_callback.ospo.expectedoutput b/examples/failscompilation/ffi_capturing_callback.ospo.expectedoutput index 5d5e6776..17030a06 100644 --- a/examples/failscompilation/ffi_capturing_callback.ospo.expectedoutput +++ b/examples/failscompilation/ffi_capturing_callback.ospo.expectedoutput @@ -1 +1 @@ -type mismatch: cannot unify int with Result +codegen: unsupported construct: a capturing lambda as an FFI callback (captures cannot cross the C boundary; use a named function) diff --git a/examples/failscompilation/function_typed_record_field.ospo b/examples/failscompilation/function_typed_record_field.ospo index 2217d3bd..85fed034 100644 --- a/examples/failscompilation/function_typed_record_field.ospo +++ b/examples/failscompilation/function_typed_record_field.ospo @@ -1,8 +1,6 @@ -// Function-typed record fields ARE a runnable feature (closure cells), but -// calling one as `a.add(10)` still goes through the UFCS rewrite -// (`add(a, 10)`) and is rejected — the spec'd field-access-wins -// disambiguation (0012-Built-InFunctions) is not implemented yet. The working -// spelling is `let f = a.add` then `f(10)`. Must reject cleanly, never panic. +// Field-call syntax resolves `a.add(10)` to the record's callable field. +// The initializer must still match that field's declared return type: +// checked addition returns Result, not int. type Adder = { add: (int) -> int } diff --git a/examples/failscompilation/function_typed_record_field.ospo.expectedoutput b/examples/failscompilation/function_typed_record_field.ospo.expectedoutput index aedf67de..5d5e6776 100644 --- a/examples/failscompilation/function_typed_record_field.ospo.expectedoutput +++ b/examples/failscompilation/function_typed_record_field.ospo.expectedoutput @@ -1,2 +1 @@ type mismatch: cannot unify int with Result -unknown identifier `add` diff --git a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo index ebe6a166..3d8d2bfa 100644 --- a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo +++ b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo @@ -1,3 +1,4 @@ +// osprey: flavor=ml (** A binding without a signature cannot declare type parameters, so it cannot be applied at a call site either. Implements [TYPE-GENERICS-APPLY], [FLAVOR-ML-GENERICS] *) diff --git a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput index 1ed7260c..96c5d771 100644 --- a/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput +++ b/examples/failscompilation/ml_turbofish_no_declared_binder.ospo.expectedoutput @@ -1 +1 @@ -7:13: function `plain` takes 0 type argument(s), got 1 +8:13: function `plain` takes 0 type argument(s), got 1 diff --git a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo index 41867cc0..7f8b4e92 100644 --- a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo +++ b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo @@ -1,3 +1,4 @@ +// osprey: flavor=ml (** The ML surface applies call-site type arguments with the same angles and is held to the same count contract — one shared core, two spellings. Implements [TYPE-GENERICS-APPLY], [FLAVOR-ML-GENERICS] *) diff --git a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput index 73b9aa34..f768c588 100644 --- a/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput +++ b/examples/failscompilation/ml_turbofish_type_arg_arity.ospo.expectedoutput @@ -1 +1 @@ -8:13: function `identity` takes 1 type argument(s), got 2 +9:13: function `identity` takes 1 type argument(s), got 2 diff --git a/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo index 34447d5f..916e86d8 100644 --- a/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo +++ b/examples/failscompilation/ml_variance_covariant_no_inward_coercion.ospo @@ -1,3 +1,4 @@ +// osprey: flavor=ml (** The ML surface lowers to the same canonical nodes, so the coercion stops at the same boundary. Implements [TYPE-VARIANCE-COERCION], [FLAVOR-ML-GENERICS] *) type Feed out T = diff --git a/examples/failscompilation/recursive_generic_needs_annotation.ospo b/examples/failscompilation/recursive_generic_needs_annotation.ospo deleted file mode 100644 index afbedb5a..00000000 --- a/examples/failscompilation/recursive_generic_needs_annotation.ospo +++ /dev/null @@ -1,11 +0,0 @@ -// A recursive function whose signature is not fully inferred cannot be -// specialised (the self-call would name a definition that is never emitted), -// so codegen fails closed and asks for annotations. `walk` stays generic in its -// element type because nothing in the body inspects an element, and the two -// call sites instantiate it at two different ones. -fn walk(xs, n) = match n { - 0 => xs - _ => walk(listReverse(xs), (n - 1) ?: 0) -} - -fn main() = print("${listLength(walk([5, 6, 7], 2))} ${listLength(walk(["a", "b"], 1))}") diff --git a/examples/failscompilation/recursive_generic_needs_annotation.ospo.expectedoutput b/examples/failscompilation/recursive_generic_needs_annotation.ospo.expectedoutput deleted file mode 100644 index c18a69a8..00000000 --- a/examples/failscompilation/recursive_generic_needs_annotation.ospo.expectedoutput +++ /dev/null @@ -1 +0,0 @@ -codegen: unsupported construct: `walk` is recursive and its return type is not inferred; annotate its return type so it is emitted as a real function diff --git a/examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo.expectedoutput b/examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo.expectedoutput index f2bc7fc1..43efabde 100644 --- a/examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo.expectedoutput +++ b/examples/failscompilation/stage_signal_instantiated_dynamic_effect.ospo.expectedoutput @@ -1 +1 @@ -11:21: `perform Signal` names an instantiation of dynamic effect `Signal`; a dynamic handler is keyed by effect name at runtime, so instantiations share one key and cannot be told apart (docs/plans/0024-staged-effects.md). Declare `static effect Signal`, or write `perform Signal` and let inference instantiate it +11:21: `perform Signal` names an instantiation of dynamic effect `Signal`; a written instantiation is the identity of a `static effect`, while a dynamic effect takes its instantiation from inference (docs/plans/0024-staged-effects.md). Declare `static effect Signal`, or write `perform Signal` and let inference instantiate it diff --git a/examples/failscompilation/staged_static_arm_requires_dynamic.ospo b/examples/failscompilation/staged_static_arm_requires_dynamic.ospo index 5a1bb38d..1d92c8d6 100644 --- a/examples/failscompilation/staged_static_arm_requires_dynamic.ospo +++ b/examples/failscompilation/staged_static_arm_requires_dynamic.ospo @@ -11,5 +11,8 @@ effect Log { fn main() = handle Log write message => print(message) in print("${handle static Tile - size => { perform Log.write("measuring") 8 } + size => { + perform Log.write("measuring") + 8 + } in perform Tile.size()}") diff --git a/examples/failscompilation/ufcs_field_collision.ospo.expectedoutput b/examples/failscompilation/ufcs_field_collision.ospo.expectedoutput index 884801e2..09a35f76 100644 --- a/examples/failscompilation/ufcs_field_collision.ospo.expectedoutput +++ b/examples/failscompilation/ufcs_field_collision.ospo.expectedoutput @@ -1 +1 @@ -type mismatch: cannot unify string with { trim: string } +cannot call non-function `string` diff --git a/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput index 5d5e6776..6207037d 100644 --- a/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput +++ b/examples/failscompilation/variance_contravariant_no_inward_coercion.ospo.expectedoutput @@ -1 +1 @@ -type mismatch: cannot unify int with Result +type mismatch: cannot unify Result with int diff --git a/examples/failscompilation/variance_in_under_two_flips.ospo b/examples/failscompilation/variance_in_under_two_flips.ospo new file mode 100644 index 00000000..c21eb304 --- /dev/null +++ b/examples/failscompilation/variance_in_under_two_flips.ospo @@ -0,0 +1,10 @@ +// Two parameter flips cancel. In `((T) -> int) -> int` the inner arrow puts `T` +// in an input position and the outer arrow flips that position again, so `T` +// ends up in OUTPUT position — which an `in T` may not occupy, exactly as if it +// had been written as a bare field. A variance check that only looked one arrow +// deep would accept this; type_equality_comprehensive.test.osp shipped it on a +// `Sink` for that reason, and the double flip belongs on `out T`. +// Implements [TYPE-VARIANCE-POSITIONS] +type Sink = Sink { admit: (T) -> bool, hof: ((T) -> int) -> int } + +fn main() -> Unit = print("must not compile") diff --git a/examples/failscompilation/variance_in_under_two_flips.ospo.expectedoutput b/examples/failscompilation/variance_in_under_two_flips.ospo.expectedoutput new file mode 100644 index 00000000..89dcd8d1 --- /dev/null +++ b/examples/failscompilation/variance_in_under_two_flips.ospo.expectedoutput @@ -0,0 +1 @@ +8:0: type parameter `T` is declared `in T` but appears in output position in field `hof` of `Sink` diff --git a/scripts/install-deslop.sh b/scripts/install-deslop.sh index ceffe6bc..cbea9afa 100755 --- a/scripts/install-deslop.sh +++ b/scripts/install-deslop.sh @@ -3,10 +3,9 @@ # # Local / devcontainer installer for the gate binary. Tracks the newest release # by default so a fresh checkout always runs the current deslop; export -# DESLOP_VERSION=X.Y.Z to pin a specific release (e.g. to dodge a bad one). CI -# installs the same gate independently via the Homebrew tap -# (`brew install nimblesite/tap/deslop`), which is likewise unpinned — so local -# and CI stay on the same current version. Downloads the release tarball, +# DESLOP_VERSION=X.Y.Z to pin a specific release. CI uses the Deslop action +# pinned to 0.27.0; use DESLOP_VERSION=0.27.0 to reproduce that gate locally. +# Downloads the release tarball, # verifies its SHA-256, and installs the `deslop` binary onto PATH. # # Usage: @@ -28,8 +27,15 @@ fail() { echo -e "${RED}✗ $*${RESET}" >&2; exit 1; } DESLOP_VERSION="${DESLOP_VERSION:-}" if [[ -z "$DESLOP_VERSION" ]]; then say "Resolving latest deslop release" - DESLOP_VERSION="$(curl -sSfL https://api.github.com/repos/Nimblesite/Deslop/releases/latest \ - | grep -m1 '"tag_name"' | sed -E 's/.*"v?([^"]+)".*/\1/')" + # No pipeline here, on purpose. `curl | grep -m1` failed the installer: + # grep exits on the first match, curl dies of SIGPIPE, and `pipefail` + # failed the whole script even though the version had been resolved. + # Piping a captured body into an early-exiting matcher has the same hazard, + # so the body is captured first and matched from a here-string. + latest="$(curl -sSfL https://api.github.com/repos/Nimblesite/Deslop/releases/latest)" \ + || fail "could not reach the GitHub API to resolve the latest deslop release" + DESLOP_VERSION="$(awk -F'"' '/"tag_name"/ { v = $4; sub(/^v/, "", v); print v; exit }' \ + <<<"$latest")" [[ -n "$DESLOP_VERSION" ]] || fail "could not resolve latest deslop release from the GitHub API" fi BASE_URL="https://github.com/Nimblesite/Deslop/releases/download/v${DESLOP_VERSION}" diff --git a/scripts/verify-no-dead-code.mjs b/scripts/verify-no-dead-code.mjs new file mode 100644 index 00000000..4f066e3a --- /dev/null +++ b/scripts/verify-no-dead-code.mjs @@ -0,0 +1,226 @@ +#!/usr/bin/env node +// Dead-code gate for the Rust workspace. [LINTS-DEADCODE-REACH] +// +// WHY THIS EXISTS. `dead_code = "deny"` (workspace Cargo.toml) catches every +// unused item that is private to a crate, and `unreachable_pub = "deny"` forces +// a `pub` item that nobody can name from outside down to `pub(crate)`, which +// puts it back under `dead_code`. One hole survives both: an item that IS +// reachable from its crate root and IS re-exported, but that no OTHER crate and +// no product code path ever names. rustc assumes such an item is a library's +// public API and stays silent, so it can rot in the tree forever. +// +// That hole is not theoretical. `osprey_debug::DebugBuild` was a two-state +// wrapper over `BuildKind` whose only callers were its own unit tests, and +// `DocComment::summary_only` was a constructor the real parser never used. +// Both compiled clean under the full lint set above. +// +// WHAT COUNTS AS DEAD. An item is dead when no PRODUCT line outside its own +// definition names it. A line is product code unless it sits in a test file +// (`tests/`, `*_tests.rs`, `test_support`/`testutil`) or inside a +// `#[cfg(test)]` block. Tests alone never keep an item alive: code whose sole +// purpose is to be tested is exactly the thing this gate removes. +// +// An item's "own definition" is its declaration block plus, for a type, every +// `impl` block for that type. Without that, a dead type looks alive because its +// own inherent methods mention it. +// +// WHAT IT DELIBERATELY MISSES. Items are tracked by bare NAME, so a dead item +// sharing a name with a live one anywhere in the workspace (`new`, `kind`, +// `path`) is held alive by its namesake, and macro-generated items are not seen +// at all. Both are FALSE NEGATIVES: the gate under-reports and never invents a +// finding, which is what lets it run with no allowlist. It is a floor on top of +// `make hawk`, not a replacement for reading the code. +// +// NO ALLOWLIST, deliberately. A gate you can turn off is not a gate. When this +// fails, the fix is to call the item or delete it, never to exempt it. + +import { readFileSync, readdirSync, statSync } from "node:fs"; +import { join, extname, resolve, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; + +const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), ".."); + +// Directories that never hold hand-written product source. +const SKIP_DIRS = new Set([ + "target", + "node_modules", + ".git", + "_site", + "out", + ".vscode-test", + "coverage", + "test-results", +]); + +// Only these can NAME a Rust item. Rust is obvious; C is here because an +// `extern "C"` declaration's real user is the C definition it links to, and +// dropping `.c`/`.h` would condemn the whole runtime FFI surface. +// +// Prose and config are deliberately absent. Markdown cannot call a function, so +// counting a doc mention as a use lets any item stay alive by being written +// about — this gate caught its own header comment resurrecting the very example +// it describes. +const REFERENCE_EXTS = new Set([".rs", ".c", ".h"]); + +const TYPE_KINDS = new Set(["struct", "enum", "trait", "union"]); + +const DECL = + /^(\s*)pub(?:\s*\(\s*(?:crate|self|super)\s*\))?\s+(?:(?:const|async|unsafe|extern\s+"[^"]*")\s+)*(fn|struct|enum|trait|type|const|static|union)\s+([A-Za-z_]\w*)/; +const IMPL = /^\s*impl\b[^{]*?\b([A-Za-z_]\w*)\s*(?:<[^{]*>)?\s*(?:where[^{]*)?\{/; +const VARIANT = /^\s{4,}([A-Z]\w*)\s*(?:[{(,=]|$)/; +const FIELD = /^\s{4,}pub\s+(?:\([^)]*\)\s*)?([a-z_]\w*)\s*:/; +const CFG_TEST = /^\s*#\[cfg\(test\)\]/; + +const walk = (dir, out = []) => { + for (const entry of readdirSync(dir)) { + if (SKIP_DIRS.has(entry)) continue; + const path = join(dir, entry); + if (statSync(path).isDirectory()) walk(path, out); + else out.push(path); + } + return out; +}; + +const isTestFile = (path) => + path.includes("/tests/") || + path.includes("/test/") || + path.endsWith("_tests.rs") || + path.includes("test_support") || + path.includes("testutil") || + path.includes("/benchmarks/"); + +// The 1-based [start, end] of the brace block opening at `start`, or of a +// single `;`-terminated declaration when no brace follows. +const blockSpan = (lines, start) => { + let depth = 0; + let sawBrace = false; + for (let j = start - 1; j < lines.length; j += 1) { + const line = lines[j]; + depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length; + if (line.includes("{")) sawBrace = true; + if (sawBrace && depth <= 0) return [start, j + 1]; + if (!sawBrace && line.trimEnd().endsWith(";")) return [start, j + 1]; + } + return [start, lines.length]; +}; + +// Every 1-based line number sitting inside a `#[cfg(test)]` block. +const testMask = (lines) => { + const mask = new Set(); + let i = 0; + while (i < lines.length) { + if (CFG_TEST.test(lines[i])) { + const [a, b] = blockSpan(lines, i + 1); + for (let k = a; k <= b; k += 1) mask.add(k); + i = b; + } else i += 1; + } + return mask; +}; + +const files = new Map(); +for (const path of walk(REPO_ROOT)) { + if (!REFERENCE_EXTS.has(extname(path))) continue; + try { + files.set(path, readFileSync(path, "utf8")); + } catch { + /* unreadable file cannot name anything */ + } +} + +const linesOf = new Map(); +const maskOf = new Map(); +for (const [path, text] of files) { + const lines = text.split("\n"); + linesOf.set(path, lines); + maskOf.set(path, path.endsWith(".rs") ? testMask(lines) : new Set()); +} + +const crateSrc = (path) => + path.startsWith(join(REPO_ROOT, "crates")) && path.endsWith(".rs") && !isTestFile(path); + +// name -> { kind, path, line, spans: [[path, start, end]] } +const items = new Map(); +const record = (name, kind, path, line, span) => { + const found = items.get(name); + if (found) found.spans.push(span); + else items.set(name, { kind, path, line, spans: [span] }); +}; + +for (const [path, text] of files) { + if (!crateSrc(path)) continue; + const lines = linesOf.get(path); + const mask = maskOf.get(path); + lines.forEach((line, index) => { + const lineNo = index + 1; + if (mask.has(lineNo)) return; + const decl = DECL.exec(line); + if (!decl) return; + const [, , kind, name] = decl; + const [a, b] = blockSpan(lines, lineNo); + record(name, kind, path, lineNo, [path, a, b]); + // Enum variants and public struct fields are members of the same block, and + // rustc treats both as used the moment the enclosing type is `pub`. + if (kind === "enum" || kind === "struct") { + for (let j = a; j < b - 1; j += 1) { + const member = kind === "enum" ? VARIANT.exec(lines[j]) : FIELD.exec(lines[j]); + if (member && member[1] !== "Self") record(member[1], `${kind} member`, path, j + 1, [path, a, b]); + } + } + }); +} + +// A type's inherent and trait `impl` blocks are part of its own definition. +for (const [path, text] of files) { + if (!path.endsWith(".rs")) continue; + const lines = linesOf.get(path); + lines.forEach((line, index) => { + const impl = IMPL.exec(line); + if (!impl) return; + const found = items.get(impl[1]); + if (!found || !TYPE_KINDS.has(found.kind)) return; + const [a, b] = blockSpan(lines, index + 1); + found.spans.push([path, a, b]); + }); +} + +const insideOwnSpans = (item, path, lineNo) => + item.spans.some(([p, a, b]) => p === path && lineNo >= a && lineNo <= b); + +const hasProductReference = (name, item) => { + const word = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`); + for (const [path, text] of files) { + if (!text.includes(name)) continue; + const testFile = isTestFile(path); + const mask = maskOf.get(path); + const lines = linesOf.get(path); + for (let i = 0; i < lines.length; i += 1) { + const lineNo = i + 1; + if (testFile || mask.has(lineNo)) continue; + if (insideOwnSpans(item, path, lineNo)) continue; + if (word.test(lines[i])) return true; + } + } + return false; +}; + +const dead = []; +for (const [name, item] of items) { + if (!hasProductReference(name, item)) dead.push({ name, ...item }); +} +dead.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line); + +if (dead.length === 0) { + console.log(`==> Dead-code gate: ${items.size} public items, all reachable from product code.`); + process.exit(0); +} + +console.error( + `FAIL: ${dead.length} public item(s) are never named by product code.\n` + + "Each is reachable only from its own definition or its own tests, so no\n" + + "rustc lint can see it. Call it from product code, or delete it.\n", +); +for (const item of dead) { + console.error(` ${item.path.slice(REPO_ROOT.length + 1)}:${item.line} ${item.kind} ${item.name}`); +} +process.exit(1); diff --git a/tests/WASM_UNPORTABLE.txt b/tests/WASM_UNPORTABLE.txt index c39e5607..484721ac 100644 --- a/tests/WASM_UNPORTABLE.txt +++ b/tests/WASM_UNPORTABLE.txt @@ -40,6 +40,7 @@ tests/regressions/basics/processes/async_process_management.test.osp process spa tests/regressions/basics/processes/async_process_management.test.ospml process spawning builtin `spawnProcess` tests/regressions/basics/processes/callback_stdout_demo.test.osp process spawning builtin `spawnProcess` tests/regressions/basics/processes/callback_stdout_demo.test.ospml process spawning builtin `spawnProcess` +tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp fiber concurrency builtin `Channel` tests/regressions/basics/website/website_examples.test.osp fiber concurrency tests/regressions/basics/website/website_examples.test.ospml fiber concurrency tests/regressions/db/database_effect.test.osp foreign C import `sqlite3_open` diff --git a/tests/effects/injection/storage_injection.test.osp b/tests/effects/injection/storage_injection.test.osp index b35c3d9b..c74266f6 100644 --- a/tests/effects/injection/storage_injection.test.osp +++ b/tests/effects/injection/storage_injection.test.osp @@ -90,14 +90,14 @@ fn withReadOnlyStorage(action) = handle Storage exists key => true in action() -/// The path each flavor owns, so the Default and ML twins never share a file. -let diskBook = "osprey_storage_injection_default.txt" -let diskArchive = "osprey_storage_injection_default_archive.txt" +/// A fresh 126-bit random suffix isolates concurrent executions of either flavor. +let diskBook = "osprey_storage_injection_${random()}_${random()}.txt" +let diskArchive = "${diskBook}.archive.txt" /// This case runs the logic against the real file system and verifies the /// bytes with `readFile` from outside the handler. fn diskStorageCase() = { - // Truncate both paths so a rerun starts from the same file system state. + /// Truncate both paths so a rerun starts from the same file system state. let clearedBook = writeFile(diskBook, "") ?: (0 - 1 ?: 0) let clearedArchive = writeFile(diskArchive, "") ?: (0 - 1 ?: 0) let first = withDiskStorage(|| => appendNote(diskBook, "buy milk")) @@ -169,7 +169,7 @@ fn mockStorageCase() = { endsWith(mockLog, "load(fixture.txt);") ]) - // The double touched no file system: nothing named by the test exists. + /// The double touched no file system: nothing named by the test exists. let notesAbsent = match readFile("notes.txt") { Success { value } => false Error { message } => contains(message, "No such file or directory") diff --git a/tests/effects/injection/storage_injection.test.ospml b/tests/effects/injection/storage_injection.test.ospml index 38a82443..342afc54 100644 --- a/tests/effects/injection/storage_injection.test.ospml +++ b/tests/effects/injection/storage_injection.test.ospml @@ -19,7 +19,7 @@ entryCount body = (** Appends one entry to `book` and answers the entry count after the write. This is the logic under test: it performs Storage and picks no handler. *) -appendNote book line = +appendNote (book, line) = updated = "${perform Storage.load book}${line}\n" _ = perform Storage.save book updated entryCount updated @@ -32,7 +32,7 @@ countNotes book = (** Copies `book` into `archive` and answers the bytes the copy reported. A book that does not exist is not copied and answers 0 bytes. *) -archiveNotes book archive = +archiveNotes (book, archive) = match perform Storage.exists book true => perform Storage.save archive (perform Storage.load book) false => 0 @@ -88,20 +88,20 @@ withReadOnlyStorage action = exists key => true in action () -(** The path each flavor owns, so the Default and ML twins never share a file. *) -diskBook = "osprey_storage_injection_ml.txt" -diskArchive = "osprey_storage_injection_ml_archive.txt" +(** A fresh 126-bit random suffix isolates concurrent executions of either flavor. *) +diskBook = "osprey_storage_injection_${random ()}_${random ()}.txt" +diskArchive = "${diskBook}.archive.txt" (** This case runs the logic against the real file system and verifies the bytes with `readFile` from outside the handler. *) diskStorageCase () = - // Truncate both paths so a rerun starts from the same file system state. + (** Truncate both paths so a rerun starts from the same file system state. *) clearedBook = writeFile diskBook "" ?: (0 - 1 ?: 0) clearedArchive = writeFile diskArchive "" ?: (0 - 1 ?: 0) - first = withDiskStorage (\() => appendNote diskBook "buy milk") - second = withDiskStorage (\() => appendNote diskBook "call dentist") + first = withDiskStorage (\() => appendNote (diskBook, "buy milk")) + second = withDiskStorage (\() => appendNote (diskBook, "call dentist")) counted = withDiskStorage (\() => countNotes diskBook) - archived = withDiskStorage (\() => archiveNotes diskBook diskArchive) + archived = withDiskStorage (\() => archiveNotes (diskBook, diskArchive)) onDisk = readFile diskBook ?: "" archivedOnDisk = readFile diskArchive ?: "" missing = withDiskStorage (\() => countNotes "osprey_storage_injection_absent.txt") @@ -132,10 +132,10 @@ test "injected disk handler persists the notebook to real files" diskStorageCase (** This case runs the identical logic against the in-memory double and verifies both the answers and the calls the logic made. *) mockStorageCase () = - first = withMockStorage (\() => appendNote "notes.txt" "buy milk") - second = withMockStorage (\() => appendNote "notes.txt" "call dentist") + first = withMockStorage (\() => appendNote ("notes.txt", "buy milk")) + second = withMockStorage (\() => appendNote ("notes.txt", "call dentist")) counted = withMockStorage (\() => countNotes "notes.txt") - archived = withMockStorage (\() => archiveNotes "notes.txt" "archive.txt") + archived = withMockStorage (\() => archiveNotes ("notes.txt", "archive.txt")) missing = withMockStorage (\() => countNotes "never-written.txt") fixture = withMockStorage (\() => countNotes "fixture.txt") stored = mapGet mockFiles "notes.txt" ?: "" @@ -165,7 +165,7 @@ mockStorageCase () = endsWith mockLog "load(fixture.txt);" ] - // The double touched no file system: nothing named by the test exists. + (** The double touched no file system: nothing named by the test exists. *) notesAbsent = match readFile "notes.txt" Success value => false @@ -184,9 +184,9 @@ test "injected mock handler replaces the file system and records every call" moc (** This case swaps in a third policy to show the logic is unchanged by it. *) readOnlyStorageCase () = savesBefore = mockSaves - appended = withReadOnlyStorage (\() => appendNote "notes.txt" "buy milk") + appended = withReadOnlyStorage (\() => appendNote ("notes.txt", "buy milk")) counted = withReadOnlyStorage (\() => countNotes "notes.txt") - archived = withReadOnlyStorage (\() => archiveNotes "notes.txt" "archive.txt") + archived = withReadOnlyStorage (\() => archiveNotes ("notes.txt", "archive.txt")) // A refused write still answers the operation's declared type, so the // logic keeps running and reports what the policy actually stored. diff --git a/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp b/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp new file mode 100644 index 00000000..3e011cc9 --- /dev/null +++ b/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp @@ -0,0 +1,22 @@ +/// A channel stored in a generic record field retains its nested element type. +/// This previously misread the received row and printed 0 instead of 3. +/// [CONCURRENCY-CHANNEL] +type Box = Box { slot: t } + +let boxed = Box { slot: Channel(2) } +send(boxed.slot, [[1, 2, 3]]) +let m = recv(boxed.slot) +print(toString(listLength(listGet(m, 0) ?: [99]))) + +/// Verifies both list levels survive the generic field and channel transfer. +fn channelElementCase() = { + let row = listGet(m, 0) ?: [99] + checkAll("channel element metadata survives a generic record field", [ + listLength(m) == 1, + listLength(row) == 3, + (listGet(row, 0) ?: 99) == 1, + (listGet(row, 1) ?: 99) == 2, + (listGet(row, 2) ?: 99) == 3 + ]) +} +test("generic record fields preserve nested channel elements", channelElementCase) diff --git a/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp.expectedoutput b/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp.expectedoutput new file mode 100644 index 00000000..c7fcefb7 --- /dev/null +++ b/tests/regressions/basics/types/channel_element_type_in_generic_field.test.osp.expectedoutput @@ -0,0 +1,4 @@ +3 +ok 1 - generic record fields preserve nested channel elements +1..1 +# tests=1 passed=1 failed=0 skipped=0 diff --git a/tests/regressions/basics/types/recursive_generic_specialization.test.osp b/tests/regressions/basics/types/recursive_generic_specialization.test.osp new file mode 100644 index 00000000..c58fd34f --- /dev/null +++ b/tests/regressions/basics/types/recursive_generic_specialization.test.osp @@ -0,0 +1,24 @@ +/// An inferred recursive function specializes at each call's element type. +/// The self-call must resolve to the matching emitted specialization. +fn walk(xs, n) = match n { + 0 => xs + _ => walk(listReverse(xs), (n - 1) ?: 0) +} + +print("${listLength(walk([5, 6, 7], 2))} ${listLength(walk(["a", "b"], 1))}") + +/// Verifies recursive integer and string specializations retain their contents. +fn recursiveGenericCase() = { + let ints = walk([5, 6, 7], 2) + let strings = walk(["a", "b"], 1) + checkAll("recursive generic calls specialize without annotations", [ + listLength(ints) == 3, + (listGet(ints, 0) ?: 0) == 5, + (listGet(ints, 1) ?: 0) == 6, + (listGet(ints, 2) ?: 0) == 7, + listLength(strings) == 2, + (listGet(strings, 0) ?: "") == "b", + (listGet(strings, 1) ?: "") == "a" + ]) +} +test("recursive generic functions specialize for integers and strings", recursiveGenericCase) diff --git a/tests/regressions/basics/types/recursive_generic_specialization.test.osp.expectedoutput b/tests/regressions/basics/types/recursive_generic_specialization.test.osp.expectedoutput new file mode 100644 index 00000000..c6be4a0c --- /dev/null +++ b/tests/regressions/basics/types/recursive_generic_specialization.test.osp.expectedoutput @@ -0,0 +1,4 @@ +3 2 +ok 1 - recursive generic functions specialize for integers and strings +1..1 +# tests=1 passed=1 failed=0 skipped=0 diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.osp b/tests/regressions/basics/types/type_equality_comprehensive.test.osp index c79a228a..74d0bf33 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.osp +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.osp @@ -113,22 +113,22 @@ print("fn-payload feed accepted: ${label(mkFeed())}") print("fn-payload gate accepted: ${describe(mkGate())}") /// --- Variance positions: every legal shape, exercised end to end --- -/// `out T` sits in a field, a function RESULT, a covariant built-in and under -/// two parameter flips; `in T` sits in a function parameter; an unannotated +/// `out T` sits in a field, a function RESULT and a covariant built-in; +/// `in T` sits in function parameters, including a callback result; an unannotated /// parameter sits in both at once. Each value is then USED, so a position that /// merely compiled but lowered wrongly is caught as well as one that was /// wrongly rejected. Assignment keeps the leaves exact under every marker — /// the refusals are in examples/failscompilation/variance_*.ospo. /// Implements [TYPE-VARIANCE-POSITIONS], [TYPE-VARIANCE-COERCION] type Source = Source { produce: T, make: (int) -> T, items: List } -type Sink = Sink { admit: (T) -> bool, hof: ((T) -> int) -> int } +type Sink = Sink { admit: (T) -> bool, hof: ((int) -> T) -> int } type Both = Both { slot: T, consume: (T) -> int } fn srcInt() -> Source = Source { produce: 4, make: |n| => n, items: [1, 2] } fn sinkInt() -> Sink = Sink { admit: |x| => true, hof: |f| => 7 } fn bothInt() -> Both = Both { slot: 5, consume: |x| => 6 } -fn keepSource(s: Source) = s.produce -fn keepSink(g: Sink) = g.hof(|n| => 3) +fn keepSource(s) = s.produce +fn keepSink(g) = g.hof(|n| => 3) print("variance produce=${srcInt().produce} make=${srcInt().make(9)} items=${length(srcInt().items)} admit=${toString(sinkInt().admit(1))} slot=${bothInt().slot} kept=${keepSource(srcInt())}/${keepSink(sinkInt())}") diff --git a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml index 63c0571a..84d7b43b 100644 --- a/tests/regressions/basics/types/type_equality_comprehensive.test.ospml +++ b/tests/regressions/basics/types/type_equality_comprehensive.test.ospml @@ -137,8 +137,8 @@ print "fn-payload feed accepted: ${label (mkFeed ())}" print "fn-payload gate accepted: ${describe (mkGate ())}" (** --- Variance positions: every legal shape, exercised end to end --- - `out T` sits in a field, a function RESULT, a covariant built-in and under - two parameter flips; `in T` sits in a function parameter; an unannotated + `out T` sits in a field, a function RESULT and a covariant built-in; + `in T` sits in function parameters, including a callback result; an unannotated parameter sits in both at once. Each value is then USED, so a position that merely compiled but lowered wrongly is caught as well as one that was wrongly rejected. Assignment keeps the leaves exact under every marker. @@ -150,7 +150,7 @@ type Source out T = items : List type Sink in T = admit : (T) -> bool - hof : ((T) -> int) -> int + hof : ((int) -> T) -> int type Both T = slot : T consume : (T) -> int @@ -230,7 +230,7 @@ typeEqualityCase () = !(identityOf false), identityOf 2.5 == 2.5, length (identityOf> ["a", "b"]) == 2, - mapLength (identityOf>> { "a": [1], "b": [2] }) == 2, + mapLength (identityOf>> ["a" => [1], "b" => [2]]) == 2, (identityOf> (Container(value = 9))).value == 9, (identityOf> (Container(value = "c"))).value == "c", isEmpty (emptyOf ()), diff --git a/tree-sitter-osprey/test/corpus/osprey.txt b/tree-sitter-osprey/test/corpus/osprey.txt index 359bbc52..191a8127 100644 --- a/tree-sitter-osprey/test/corpus/osprey.txt +++ b/tree-sitter-osprey/test/corpus/osprey.txt @@ -690,7 +690,7 @@ fn main() = identity>([1]) (expression (primary_expression (literal - (integer))))))))))))) + (integer)))))))))))))) ================================================================================ A spaced comparison is not type application [TYPE-GENERICS-APPLY] diff --git a/vscode-extension/client/src/extension.ts b/vscode-extension/client/src/extension.ts index b70234b0..2d9b00f8 100644 --- a/vscode-extension/client/src/extension.ts +++ b/vscode-extension/client/src/extension.ts @@ -548,7 +548,7 @@ export function activate(context: ExtensionContext) { // Register debug configuration provider context.subscriptions.push( debug.registerDebugConfigurationProvider("osprey", { - async resolveDebugConfiguration(folder: any, config: any, token: any) { + async resolveDebugConfiguration(_folder: any, config: any, _token: any) { // If no config is provided, synthesize one from the active osprey editor. config = applyDefaultOspreyDebugConfig(config, window.activeTextEditor); diff --git a/vscode-extension/run-tests.sh b/vscode-extension/run-tests.sh deleted file mode 100755 index 5df7002f..00000000 --- a/vscode-extension/run-tests.sh +++ /dev/null @@ -1,78 +0,0 @@ -#!/bin/bash - -# Test runner for Osprey VSCode Extension -# This script runs the comprehensive test suite to verify all features - -set -e - -echo "🧪 Osprey Extension Test Runner" -echo "================================" - -# Check if we're in the right directory -if [ ! -f "package.json" ]; then - echo "❌ Error: Must be run from the VS Code Extension directory" - exit 1 -fi - -# Check if osprey compiler is available -if ! command -v osprey &> /dev/null; then - echo "❌ Error: osprey compiler not found in PATH" - echo " Please build the Rust compiler and put it on PATH first:" - echo " cd .. && cargo build --release # binary: target/release/osprey" - exit 1 -fi - -echo "✅ Osprey compiler found: $(which osprey)" - -# Install dependencies if needed -if [ ! -d "node_modules" ]; then - echo "📦 Installing dependencies..." - npm install -fi - -# Compile TypeScript -echo "🔨 Compiling TypeScript..." -npm run compile - -# Build the extension -echo "📦 Building extension package..." -npm run package - -# Run the tests -echo "🧪 Running comprehensive test suite..." -echo "" -echo "Tests include:" -echo " ✅ Basic extension activation" -echo " ✅ Language server integration" -echo " ✅ Hover documentation (from compiler)" -echo " ✅ Built-in function documentation" -echo " ✅ Pipe operator documentation" -echo " ✅ Signature help" -echo " ✅ Diagnostics and error reporting" -echo " ✅ Document symbols" -echo " ✅ Code completion" -echo " ✅ Compiler integration verification" -echo "" - -# Run tests with timeout -timeout 300 npm test || { - echo "❌ Tests failed or timed out" - exit 1 -} - -echo "" -echo "🎉 All tests completed successfully!" -echo "" -echo "📋 Test Coverage:" -echo " ✅ Extension activation and basic functionality" -echo " ✅ Language server startup and communication" -echo " ✅ Dynamic documentation from compiler" -echo " ✅ All built-in functions have hover support" -echo " ✅ Pipe operator documentation" -echo " ✅ Function signature help" -echo " ✅ Syntax error diagnostics" -echo " ✅ Symbol navigation" -echo " ✅ Code completion" -echo " ✅ Compiler integration verification" -echo "" -echo "🚀 Extension is ready for use!" \ No newline at end of file diff --git a/vscode-extension/test/suite/debug.e2e.test.ts b/vscode-extension/test/suite/debug.e2e.test.ts index 897f70c2..0906d3a2 100644 --- a/vscode-extension/test/suite/debug.e2e.test.ts +++ b/vscode-extension/test/suite/debug.e2e.test.ts @@ -6,11 +6,7 @@ import * as fs from "fs"; import * as path from "path"; import * as vscode from "vscode"; import { defaultDebugOutputPath } from "../../client/src/extension"; -import { - extensionRoot, - resolveBuiltOsprey, - resolveRequiredLldbDap, -} from "./osprey-test-env"; +import { resolveBuiltOsprey, resolveRequiredLldbDap } from "./osprey-test-env"; import { assertCurrentLine, assertLocalVariable, diff --git a/vscode-extension/tsconfig.json b/vscode-extension/tsconfig.json index 750fcc06..a7afe1b1 100644 --- a/vscode-extension/tsconfig.json +++ b/vscode-extension/tsconfig.json @@ -8,6 +8,8 @@ "sourceMap": true, "rootDir": ".", "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, "moduleResolution": "node16", "esModuleInterop": true, "skipLibCheck": true, diff --git a/website/start-dev.sh b/website/start-dev.sh deleted file mode 100644 index be9edcb0..00000000 --- a/website/start-dev.sh +++ /dev/null @@ -1,51 +0,0 @@ -#!/bin/bash - -echo "🌐 Starting Osprey Website (Dev/Local)..." -echo "================================================" -echo "" -echo "This will start the Osprey website development server:" -echo "- Static site generator (Eleventy/11ty)" -echo "- Hot reload for development" -echo "- Syntax highlighting for Osprey code" -echo "" -echo "Access the website at: http://localhost:8080" -echo "" -echo "================================================" - -# Navigate to website directory -cd "$(dirname "$0")" - -# Detect if we're in a dev container or local environment -if [ -f "/usr/lib/node_modules/npm/bin/npm-cli.js" ]; then - NPM_CMD="/usr/lib/node_modules/npm/bin/npm-cli.js" - echo "🐳 Detected dev container environment" -else - NPM_CMD="npm" - echo "💻 Detected local environment" - - # Check if Node.js and npm are installed locally - if ! command -v node &> /dev/null; then - echo "❌ Node.js is required but not installed!" - echo "Install Node.js from: https://nodejs.org/" - exit 1 - fi - - if ! command -v npm &> /dev/null; then - echo "❌ npm is required but not installed!" - echo "Install npm with Node.js from: https://nodejs.org/" - exit 1 - fi -fi - -# Check if dependencies are installed -if [ ! -d "node_modules" ]; then - echo "📦 Installing website dependencies..." - $NPM_CMD install -fi - -# Start the development server -echo "🚀 Starting Eleventy development server..." -echo " - Building site and watching for changes..." -echo " - Server will start on port 8080 (accessible from host)" -echo "" -/usr/lib/node_modules/npm/bin/npm-cli.js run dev \ No newline at end of file