From 5cd45385b4ee82c1ea1ee8c3a60093aa85c55ded Mon Sep 17 00:00:00 2001 From: Mike Voronov Date: Wed, 24 Nov 2021 17:57:14 +0300 Subject: [PATCH] Introduce restriction operator for streams (#172) --- CHANGELOG.md | 14 + Cargo.lock | 6 +- air-interpreter/Cargo.toml | 2 +- air/Cargo.toml | 4 +- air/src/execution_step/air/ap.rs | 6 +- .../air/ap/apply_to_arguments.rs | 5 +- air/src/execution_step/air/ap/utils.rs | 2 +- .../air/call/call_result_setter.rs | 45 +- air/src/execution_step/air/fold/utils.rs | 4 +- air/src/execution_step/air/fold_scalar.rs | 2 +- air/src/execution_step/air/fold_stream.rs | 4 +- air/src/execution_step/air/mod.rs | 10 +- air/src/execution_step/air/new.rs | 64 + .../execution_step/boxed_value/variable.rs | 48 +- air/src/execution_step/errors.rs | 4 +- .../execution_context/context.rs | 11 +- .../execution_step/execution_context/mod.rs | 2 + .../execution_context/scalar_variables.rs | 27 +- .../scalar_variables/traits.rs | 39 + .../execution_context/streams_variables.rs | 224 ++ air/src/execution_step/utils/resolve.rs | 10 +- air/src/preparation_step/preparation.rs | 7 +- air/src/runner/outcome.rs | 21 +- air/tests/test_module/instructions/mod.rs | 1 + air/tests/test_module/instructions/new.rs | 289 +++ .../test_module/integration/data_merge.rs | 8 +- air/tests/test_module/integration/join.rs | 10 +- .../air-parser/src/ast/instructions.rs | 13 +- .../air-parser/src/ast/instructions/impls.rs | 118 + .../air-parser/src/ast/instructions/traits.rs | 9 +- crates/air-lib/air-parser/src/ast/mod.rs | 1 + crates/air-lib/air-parser/src/ast/values.rs | 4 + .../air-parser/src/ast/values/impls.rs | 84 +- .../air-lib/air-parser/src/parser/air.lalrpop | 99 +- crates/air-lib/air-parser/src/parser/air.rs | 1982 +++++++++-------- .../air-parser/src/parser/air_parser.rs | 3 + .../air-lib/air-parser/src/parser/errors.rs | 3 + .../air-parser/src/parser/lexer/air_lexer.rs | 6 +- .../src/parser/lexer/call_variable_parser.rs | 22 +- .../air-parser/src/parser/lexer/tests.rs | 11 +- .../air-parser/src/parser/lexer/token.rs | 7 +- crates/air-lib/air-parser/src/parser/mod.rs | 8 +- crates/air-lib/air-parser/src/parser/span.rs | 34 + .../air-lib/air-parser/src/parser/tests/ap.rs | 8 +- .../air-parser/src/parser/tests/call.rs | 59 +- .../air-parser/src/parser/tests/dsl.rs | 28 +- .../air-parser/src/parser/tests/fold.rs | 27 +- .../air-parser/src/parser/tests/match_.rs | 14 +- .../air-parser/src/parser/tests/mod.rs | 1 + .../air-parser/src/parser/tests/new.rs | 84 + .../air-parser/src/parser/tests/seq.rs | 24 +- .../air-parser/src/parser/validator.rs | 19 + .../src/instructions_tracker.rs | 31 + crates/air-lib/interpreter-data/CHANGELOG.md | 5 + crates/air-lib/interpreter-data/Cargo.toml | 2 +- .../interpreter-data/src/interpreter_data.rs | 70 +- crates/air-lib/interpreter-data/src/lib.rs | 15 +- .../src/stream_generations.rs | 31 + .../air-lib/test-utils/src/executed_state.rs | 9 +- crates/air-lib/test-utils/src/lib.rs | 2 +- .../src/data_keeper/merge_ctx.rs | 6 +- 61 files changed, 2484 insertions(+), 1224 deletions(-) create mode 100644 air/src/execution_step/air/new.rs create mode 100644 air/src/execution_step/execution_context/scalar_variables/traits.rs create mode 100644 air/src/execution_step/execution_context/streams_variables.rs create mode 100644 air/tests/test_module/instructions/new.rs create mode 100644 crates/air-lib/air-parser/src/parser/span.rs create mode 100644 crates/air-lib/air-parser/src/parser/tests/new.rs create mode 100644 crates/air-lib/interpreter-data/src/stream_generations.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 8a538aca..d37c2973 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,17 @@ +## Version 0.17.0 (2021-11-24) + +[PR 172](https://github.com/fluencelabs/aquavm/pull/172): +A new instruction intended to restrict a scope of variables was introduced to AquaVM. + +[PR 168](https://github.com/fluencelabs/aquavm/pull/168): +AIR parser and AST was highly refactored to be more suitable to the scalar/stream restriction scheme used in AIR instructions. + +[PR 164](https://github.com/fluencelabs/aquavm/pull/164): +SecurityTetraplet was decoupled with marine-rs-sdk to have the only one definition in AquaVM that then exported by marine-rs-sdk. + +[PR 162](https://github.com/fluencelabs/aquavm/pull/162): +The scalar scoping scheme was improved in order to support more than two scope levels. + ## Version 0.16.0 (2021-10-18) [PR 154](https://github.com/fluencelabs/aquavm/pull/154) diff --git a/Cargo.lock b/Cargo.lock index 8a88fa11..0b53f4ff 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -13,7 +13,7 @@ dependencies = [ [[package]] name = "air" -version = "0.16.0" +version = "0.17.0" dependencies = [ "air-execution-info-collector", "air-interpreter-data", @@ -49,7 +49,7 @@ version = "0.1.0" [[package]] name = "air-interpreter" -version = "0.16.0" +version = "0.17.0" dependencies = [ "air", "air-log-targets", @@ -62,7 +62,7 @@ dependencies = [ [[package]] name = "air-interpreter-data" -version = "0.2.0" +version = "0.2.2" dependencies = [ "once_cell", "semver 1.0.4", diff --git a/air-interpreter/Cargo.toml b/air-interpreter/Cargo.toml index 8b04db04..fd0f6e6b 100644 --- a/air-interpreter/Cargo.toml +++ b/air-interpreter/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "air-interpreter" -version = "0.16.0" +version = "0.17.0" description = "Crate-wrapper for air" authors = ["Fluence Labs"] edition = "2018" diff --git a/air/Cargo.toml b/air/Cargo.toml index 31bf6b35..dae91939 100644 --- a/air/Cargo.toml +++ b/air/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "air" -version = "0.16.0" +version = "0.17.0" description = "Interpreter of AIR scripts intended to coordinate request flow in the Fluence network" authors = ["Fluence Labs"] edition = "2018" @@ -30,6 +30,7 @@ serde = { version = "1.0.118", features = [ "derive", "rc" ] } serde_json = "1.0.61" boolinator = "2.4.0" +maplit = "1.0.2" log = "0.4.11" thiserror = "1.0.23" strum = "0.21" @@ -46,7 +47,6 @@ criterion = "0.3.3" csv = "1.1.5" once_cell = "1.4.1" env_logger = "0.7.1" -maplit = "1.0.2" pretty_assertions = "0.6.1" serde_json = "1.0.61" diff --git a/air/src/execution_step/air/ap.rs b/air/src/execution_step/air/ap.rs index a3184d81..463f0da9 100644 --- a/air/src/execution_step/air/ap.rs +++ b/air/src/execution_step/air/ap.rs @@ -17,7 +17,6 @@ mod apply_to_arguments; mod utils; -use super::call::call_result_setter::set_stream_result; use super::ExecutionCtx; use super::ExecutionResult; use super::TraceHandler; @@ -75,7 +74,10 @@ fn save_result<'ctx>( Scalar(scalar) => exec_ctx.scalars.set_value(scalar.name, result).map(|_| ()), Stream(stream) => { let generation = ap_result_to_generation(merger_ap_result); - set_stream_result(result, generation, stream.name.to_string(), exec_ctx).map(|_| ()) + exec_ctx + .streams + .add_stream_value(result, generation, stream.name, stream.position) + .map(|_| ()) } } } diff --git a/air/src/execution_step/air/ap/apply_to_arguments.rs b/air/src/execution_step/air/ap/apply_to_arguments.rs index 5ff0b9b6..ca8f8a26 100644 --- a/air/src/execution_step/air/ap/apply_to_arguments.rs +++ b/air/src/execution_step/air/ap/apply_to_arguments.rs @@ -69,7 +69,7 @@ fn apply_scalar( ) -> ExecutionResult { // TODO: refactor this code after boxed value match &scalar.lambda { - Some(lambda) => apply_scalar_wl_impl(scalar.name, lambda, exec_ctx, trace_ctx), + Some(lambda) => apply_scalar_wl_impl(scalar.name, scalar.position, lambda, exec_ctx, trace_ctx), None => apply_scalar_impl(scalar.name, exec_ctx, trace_ctx, should_touch_trace), } } @@ -104,11 +104,12 @@ fn apply_scalar_impl( fn apply_scalar_wl_impl( scalar_name: &str, + position: usize, lambda: &LambdaAST<'_>, exec_ctx: &ExecutionCtx<'_>, trace_ctx: &TraceHandler, ) -> ExecutionResult { - let variable = Variable::scalar(scalar_name); + let variable = Variable::scalar(scalar_name, position); let (jvalue, mut tetraplets) = apply_lambda(variable, lambda, exec_ctx)?; let tetraplet = tetraplets diff --git a/air/src/execution_step/air/ap/utils.rs b/air/src/execution_step/air/ap/utils.rs index fbf2b328..977628f6 100644 --- a/air/src/execution_step/air/ap/utils.rs +++ b/air/src/execution_step/air/ap/utils.rs @@ -80,7 +80,7 @@ fn variable_to_generations(variable: &ast::Variable<'_>, exec_ctx: &ExecutionCtx Stream(stream) => { // unwrap here is safe because this function will be called only // when this stream's been created - let stream = exec_ctx.streams.get(stream.name).unwrap(); + let stream = exec_ctx.streams.get(stream.name, stream.position).unwrap(); let generation = match stream.borrow().generations_count() { 0 => 0, n => n - 1, diff --git a/air/src/execution_step/air/call/call_result_setter.rs b/air/src/execution_step/air/call/call_result_setter.rs index 85a2cf4a..1365da5e 100644 --- a/air/src/execution_step/air/call/call_result_setter.rs +++ b/air/src/execution_step/air/call/call_result_setter.rs @@ -17,7 +17,6 @@ use super::*; use crate::execution_step::execution_context::*; use crate::execution_step::Generation; -use crate::execution_step::Stream; use crate::execution_step::ValueAggregate; use air_interpreter_data::CallResult; @@ -26,9 +25,6 @@ use air_parser::ast::CallOutputValue; use air_parser::ast::Variable; use air_trace_handler::TraceHandler; -use std::cell::RefCell; -use std::collections::hash_map::Entry::{Occupied, Vacant}; - /// Writes result of a local `Call` instruction to `ExecutionCtx` at `output`. /// Returns call result. pub(crate) fn set_local_result<'i>( @@ -44,12 +40,21 @@ pub(crate) fn set_local_result<'i>( } CallOutputValue::Variable(Variable::Stream(stream)) => { // TODO: refactor this generation handling - let generation = match exec_ctx.streams.get(stream.name) { - Some(stream) => Generation::Nth(stream.borrow().generations_count() as u32 - 1), + let generation = match exec_ctx.streams.get(stream.name, stream.position) { + Some(stream) => { + let generation = match stream.borrow().generations_count() { + 0 => 0, + n => n - 1, + }; + Generation::Nth(generation as u32) + } None => Generation::Last, }; - let generation = set_stream_result(executed_result, generation, stream.name.to_string(), exec_ctx)?; + let generation = + exec_ctx + .streams + .add_stream_value(executed_result, generation, stream.name, stream.position)?; Ok(CallResult::executed_stream(result_value, generation)) } CallOutputValue::None => Ok(CallResult::executed_scalar(result_value)), @@ -71,7 +76,9 @@ pub(crate) fn set_result_from_value<'i>( (CallOutputValue::Variable(Variable::Stream(stream)), Value::Stream { value, generation }) => { let result = ValueAggregate::new(value, tetraplet, trace_pos); let generation = Generation::Nth(generation); - let _ = set_stream_result(result, generation, stream.name.to_string(), exec_ctx)?; + let _ = exec_ctx + .streams + .add_stream_value(result, generation, stream.name, stream.position)?; } // it isn't needed to check there that output and value matches because // it's been already checked in trace handler @@ -81,28 +88,6 @@ pub(crate) fn set_result_from_value<'i>( Ok(()) } -// TODO: decouple this function to a separate module -pub(crate) fn set_stream_result( - executed_result: ValueAggregate, - generation: Generation, - stream_name: String, - exec_ctx: &mut ExecutionCtx<'_>, -) -> ExecutionResult { - let generation = match exec_ctx.streams.entry(stream_name) { - Occupied(mut entry) => { - // if result is an array, insert result to the end of the array - entry.get_mut().borrow_mut().add_value(executed_result, generation)? - } - Vacant(entry) => { - let stream = Stream::from_value(executed_result); - entry.insert(RefCell::new(stream)); - 0 - } - }; - - Ok(generation) -} - /// Writes an executed state of a particle being sent to remote node. pub(crate) fn set_remote_call_result<'i>( peer_pk: String, diff --git a/air/src/execution_step/air/fold/utils.rs b/air/src/execution_step/air/fold/utils.rs index bbae7c3d..80fd16d4 100644 --- a/air/src/execution_step/air/fold/utils.rs +++ b/air/src/execution_step/air/fold/utils.rs @@ -51,10 +51,10 @@ pub(crate) fn construct_scalar_iterable_value<'ctx>( /// Constructs iterable value for given stream iterable. pub(crate) fn construct_stream_iterable_value<'ctx>( - stream_name: &'ctx str, + stream: &ast::Stream<'_>, exec_ctx: &ExecutionCtx<'ctx>, ) -> ExecutionResult { - match exec_ctx.streams.get(stream_name) { + match exec_ctx.streams.get(stream.name, stream.position) { Some(stream) => { let stream = stream.borrow(); if stream.is_empty() { diff --git a/air/src/execution_step/air/fold_scalar.rs b/air/src/execution_step/air/fold_scalar.rs index 12417399..5193aa93 100644 --- a/air/src/execution_step/air/fold_scalar.rs +++ b/air/src/execution_step/air/fold_scalar.rs @@ -29,7 +29,7 @@ impl<'i> ExecutableInstruction<'i> for FoldScalar<'i> { fn execute(&self, exec_ctx: &mut ExecutionCtx<'i>, trace_ctx: &mut TraceHandler) -> ExecutionResult<()> { log_instruction!(fold, exec_ctx, trace_ctx); - exec_ctx.scalars.meet_fold_begin(); + exec_ctx.scalars.meet_fold_start(); let fold_result = match construct_scalar_iterable_value(&self.iterable, exec_ctx)? { FoldIterableScalar::Empty => Ok(()), diff --git a/air/src/execution_step/air/fold_stream.rs b/air/src/execution_step/air/fold_stream.rs index ebeac231..b55039f6 100644 --- a/air/src/execution_step/air/fold_stream.rs +++ b/air/src/execution_step/air/fold_stream.rs @@ -29,14 +29,14 @@ impl<'i> ExecutableInstruction<'i> for FoldStream<'i> { fn execute(&self, exec_ctx: &mut ExecutionCtx<'i>, trace_ctx: &mut TraceHandler) -> ExecutionResult<()> { log_instruction!(fold, exec_ctx, trace_ctx); - let iterables = match construct_stream_iterable_value(self.iterable.name, exec_ctx)? { + let iterables = match construct_stream_iterable_value(&self.iterable, exec_ctx)? { FoldIterableStream::Empty => return Ok(()), FoldIterableStream::Stream(iterables) => iterables, }; let fold_id = exec_ctx.tracker.fold.seen_stream_count; trace_to_exec_err!(trace_ctx.meet_fold_start(fold_id))?; - exec_ctx.scalars.meet_fold_begin(); + exec_ctx.scalars.meet_fold_start(); for iterable in iterables { let value = match iterable.peek() { diff --git a/air/src/execution_step/air/mod.rs b/air/src/execution_step/air/mod.rs index 40e8df71..499a6f19 100644 --- a/air/src/execution_step/air/mod.rs +++ b/air/src/execution_step/air/mod.rs @@ -22,6 +22,7 @@ mod fold_scalar; mod fold_stream; mod match_; mod mismatch; +mod new; mod next; mod null; mod par; @@ -126,6 +127,7 @@ impl<'i> ExecutableInstruction<'i> for Instruction<'i> { Instruction::Ap(ap) => execute!(self, ap, exec_ctx, trace_ctx), Instruction::FoldScalar(fold) => execute!(self, fold, exec_ctx, trace_ctx), Instruction::FoldStream(fold) => execute_fold!(self, fold, exec_ctx, trace_ctx), + Instruction::New(new) => execute!(self, new, exec_ctx, trace_ctx), Instruction::Next(next) => execute!(self, next, exec_ctx, trace_ctx), Instruction::Null(null) => execute!(self, null, exec_ctx, trace_ctx), Instruction::Par(par) => execute!(self, par, exec_ctx, trace_ctx), @@ -147,16 +149,10 @@ macro_rules! log_instruction { log::debug!(target: air_log_targets::INSTRUCTION, "> {}", stringify!($instr_name)); let mut variables = String::from(" scalars:"); - variables.push_str(&format!("\n {}", $exec_ctx.scalars)); variables.push_str(" streams:"); - if $exec_ctx.streams.is_empty() { - variables.push_str(" empty"); - } - for (key, value) in $exec_ctx.streams.iter() { - variables.push_str(&format!("\n {} => {}", key, value.borrow())); - } + variables.push_str(&format!("\n {}", $exec_ctx.streams)); log::trace!(target: air_log_targets::DATA_CACHE, "{}", variables); log::trace!( diff --git a/air/src/execution_step/air/new.rs b/air/src/execution_step/air/new.rs new file mode 100644 index 00000000..1ef9ad96 --- /dev/null +++ b/air/src/execution_step/air/new.rs @@ -0,0 +1,64 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use super::ExecutionCtx; +use super::ExecutionResult; +use super::TraceHandler; +use crate::log_instruction; + +use air_parser::ast::New; +use air_parser::ast::Variable; + +impl<'i> super::ExecutableInstruction<'i> for New<'i> { + fn execute(&self, exec_ctx: &mut ExecutionCtx<'i>, trace_ctx: &mut TraceHandler) -> ExecutionResult<()> { + log_instruction!(new, exec_ctx, trace_ctx); + + prolog(self, exec_ctx); + // it should be a lazy error evaluating after execution of epilog block, since it's + // necessary to return a restricted variable to it's previous state in case of + // any error. It's highly important to distinguish between global and restricted streams + // at the end of execution to make a correct data. + let instruction_result = self.instruction.execute(exec_ctx, trace_ctx); + epilog(self, exec_ctx); + + instruction_result + } +} + +fn prolog<'i>(new: &New<'i>, exec_ctx: &mut ExecutionCtx<'i>) { + let position = new.span.left; + match &new.variable { + Variable::Stream(stream) => { + let iteration = exec_ctx.tracker.new_tracker.get_iteration(position); + exec_ctx.streams.meet_scope_start(stream.name, new.span, iteration); + } + // noop + Variable::Scalar(_) => {} + } + + exec_ctx.tracker.meet_new(position); +} + +fn epilog<'i>(new: &New<'i>, exec_ctx: &mut ExecutionCtx<'i>) { + let position = new.span.left; + match &new.variable { + Variable::Stream(stream) => exec_ctx + .streams + .meet_scope_end(stream.name.to_string(), position as u32), + // noop + Variable::Scalar(_) => {} + } +} diff --git a/air/src/execution_step/boxed_value/variable.rs b/air/src/execution_step/boxed_value/variable.rs index c07af07e..9280a677 100644 --- a/air/src/execution_step/boxed_value/variable.rs +++ b/air/src/execution_step/boxed_value/variable.rs @@ -19,32 +19,28 @@ use air_parser::ast; #[derive(Clone, Copy, Debug)] pub(crate) enum Variable<'i> { - Scalar(&'i str), - Stream { name: &'i str, generation: Generation }, + #[allow(dead_code)] + // position will be needed to implement new for operators + Scalar { name: &'i str, position: usize }, + Stream { + name: &'i str, + generation: Generation, + position: usize, + }, } impl<'i> Variable<'i> { - pub(crate) fn scalar(name: &'i str) -> Self { - Self::Scalar(name) + pub(crate) fn scalar(name: &'i str, position: usize) -> Self { + Self::Scalar { name, position } } - #[allow(dead_code)] - pub(crate) fn from_ast_with_generation(ast_variable: &ast::Variable<'i>, generation: Generation) -> Self { - use ast::Variable::*; - - match ast_variable { - Scalar(scalar) => Variable::Scalar(scalar.name), - Stream(stream) => Variable::Stream { - name: stream.name, - generation, - }, + pub(crate) fn stream(name: &'i str, generation: Generation, position: usize) -> Self { + Self::Stream { + name, + generation, + position, } } - - #[allow(dead_code)] - pub(crate) fn from_stream(name: &'i str, generation: Generation) -> Self { - Self::Stream { name, generation } - } } impl<'i> From<&ast::Variable<'i>> for Variable<'i> { @@ -52,11 +48,8 @@ impl<'i> From<&ast::Variable<'i>> for Variable<'i> { use ast::Variable::*; match ast_variable { - Scalar(scalar) => Self::Scalar(scalar.name), - Stream(stream) => Self::Stream { - name: stream.name, - generation: Generation::Last, - }, + Scalar(scalar) => Self::scalar(scalar.name, scalar.position), + Stream(stream) => Self::stream(stream.name, Generation::Last, stream.position), } } } @@ -66,11 +59,8 @@ impl<'i> From<&ast::VariableWithLambda<'i>> for Variable<'i> { use ast::VariableWithLambda::*; match ast_variable { - Scalar(scalar) => Self::Scalar(scalar.name), - Stream(stream) => Self::Stream { - name: stream.name, - generation: Generation::Last, - }, + Scalar(scalar) => Self::scalar(scalar.name, scalar.position), + Stream(stream) => Self::stream(stream.name, Generation::Last, stream.position), } } } diff --git a/air/src/execution_step/errors.rs b/air/src/execution_step/errors.rs index 950e8872..817a32fa 100644 --- a/air/src/execution_step/errors.rs +++ b/air/src/execution_step/errors.rs @@ -42,8 +42,8 @@ pub(crate) enum ExecutionError { #[error("Local service error, ret_code is {0}, error message is '{1}'")] LocalServiceError(i32, Rc), - /// Value for such name isn't presence in data. - #[error("variable with name '{0}' isn't present in data")] + /// Variable with such a name wasn't defined during AIR script execution. + #[error("variable with name '{0}' wasn't defined during script execution")] VariableNotFound(String), /// Multiple values for such name found. diff --git a/air/src/execution_step/execution_context/context.rs b/air/src/execution_step/execution_context/context.rs index 827968e1..1cf48fab 100644 --- a/air/src/execution_step/execution_context/context.rs +++ b/air/src/execution_step/execution_context/context.rs @@ -17,13 +17,11 @@ use super::LastErrorDescriptor; use super::LastErrorWithTetraplet; use super::Scalars; -use crate::execution_step::boxed_value::Stream; +use super::Streams; use air_execution_info_collector::InstructionTracker; use air_interpreter_interface::*; -use std::cell::RefCell; -use std::collections::HashMap; use std::rc::Rc; /// Contains all necessary state needed to execute AIR script. @@ -33,8 +31,7 @@ pub(crate) struct ExecutionCtx<'i> { pub(crate) scalars: Scalars<'i>, /// Contains all streams. - // TODO: use shared string (Rc) to avoid copying. - pub(crate) streams: HashMap>, + pub(crate) streams: Streams, /// Set of peer public keys that should receive resulted data. pub(crate) next_peer_pks: Vec, @@ -116,9 +113,7 @@ impl<'i> Display for ExecutionCtx<'i> { writeln!(f, " {}", self.scalars)?; writeln!(f, "streams:")?; - for (name, stream) in self.streams.iter() { - writeln!(f, " {} => {}", name, stream.borrow())?; - } + writeln!(f, " {}", self.streams)?; writeln!(f, "current peer id: {}", self.current_peer_id)?; writeln!(f, "subtree complete: {}", self.subtree_complete)?; diff --git a/air/src/execution_step/execution_context/mod.rs b/air/src/execution_step/execution_context/mod.rs index 483e0e77..c64fc887 100644 --- a/air/src/execution_step/execution_context/mod.rs +++ b/air/src/execution_step/execution_context/mod.rs @@ -17,9 +17,11 @@ mod context; mod error_descriptor; mod scalar_variables; +mod streams_variables; pub(crate) use context::*; pub use error_descriptor::LastError; pub(crate) use error_descriptor::LastErrorDescriptor; pub(crate) use error_descriptor::LastErrorWithTetraplet; pub(crate) use scalar_variables::*; +pub(crate) use streams_variables::*; diff --git a/air/src/execution_step/execution_context/scalar_variables.rs b/air/src/execution_step/execution_context/scalar_variables.rs index 78b5de2c..cbb846a6 100644 --- a/air/src/execution_step/execution_context/scalar_variables.rs +++ b/air/src/execution_step/execution_context/scalar_variables.rs @@ -70,7 +70,6 @@ pub(crate) struct Scalars<'i> { pub fold_block_id: usize, } -#[allow(dead_code)] impl<'i> Scalars<'i> { /// Returns true if there was a previous value for the provided key on the same /// fold block. @@ -122,10 +121,6 @@ impl<'i> Scalars<'i> { } } - pub(crate) fn remove_value(&mut self, name: &str) { - self.values.remove(name); - } - pub(crate) fn remove_iterable_value(&mut self, name: &str) { self.iterable_values.remove(name); } @@ -143,26 +138,6 @@ impl<'i> Scalars<'i> { .ok_or_else(|| Rc::new(ExecutionError::VariableNotFound(name.to_string()))) } - pub(crate) fn get_value_mut(&'i mut self, name: &str) -> ExecutionResult<&'i mut ValueAggregate> { - let fold_block_id = self.fold_block_id; - self.values - .get_mut(name) - .and_then(|scalars| { - scalars - .iter_mut() - .take(fold_block_id) - .rev() - .find_map(|scalar| scalar.as_mut()) - }) - .ok_or_else(|| Rc::new(ExecutionError::VariableNotFound(name.to_string()))) - } - - pub(crate) fn get_iterable(&self, name: &str) -> ExecutionResult<&FoldState<'i>> { - self.iterable_values - .get(name) - .ok_or_else(|| Rc::new(ExecutionError::FoldStateNotFound(name.to_string()))) - } - pub(crate) fn get_iterable_mut(&mut self, name: &str) -> ExecutionResult<&mut FoldState<'i>> { self.iterable_values .get_mut(name) @@ -181,7 +156,7 @@ impl<'i> Scalars<'i> { } } - pub(crate) fn meet_fold_begin(&mut self) { + pub(crate) fn meet_fold_start(&mut self) { self.fold_block_id += 1; } diff --git a/air/src/execution_step/execution_context/scalar_variables/traits.rs b/air/src/execution_step/execution_context/scalar_variables/traits.rs new file mode 100644 index 00000000..765c6ca7 --- /dev/null +++ b/air/src/execution_step/execution_context/scalar_variables/traits.rs @@ -0,0 +1,39 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use super::Scalars; + +use std::fmt; + +impl<'i> fmt::Display for Scalars<'i> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!(f, "fold_block_id: {}", self.fold_blocks_sequence.len())?; + + for (name, _) in self.values.iter() { + let descriptor = self.values.get(name); + if let Some(descriptor) = descriptor { + writeln!(f, "{} => {:?}", name, descriptor.values.last())?; + } + } + + for (name, _) in self.iterable_values.iter() { + // it's impossible to print an iterable value for now + writeln!(f, "{} => iterable", name)?; + } + + Ok(()) + } +} diff --git a/air/src/execution_step/execution_context/streams_variables.rs b/air/src/execution_step/execution_context/streams_variables.rs new file mode 100644 index 00000000..b130e815 --- /dev/null +++ b/air/src/execution_step/execution_context/streams_variables.rs @@ -0,0 +1,224 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use crate::execution_step::ExecutionResult; +use crate::execution_step::Generation; +use crate::execution_step::Stream; +use crate::execution_step::ValueAggregate; + +use air_interpreter_data::GlobalStreamGens; +use air_interpreter_data::RestrictedStreamGens; + +use std::cell::RefCell; +use std::collections::hash_map::Entry::{Occupied, Vacant}; +use std::collections::HashMap; + +#[derive(Default)] +pub(crate) struct Streams { + // this one is optimized for speed (not for memory), because it's unexpected + // that a script could have a lot of new. + // TODO: use shared string (Rc) to avoid copying. + streams: HashMap>, + + /// Contains stream generation that private stream should have at the scope start. + data_restr_stream_generations: RestrictedStreamGens, + + /// Contains stream generations that each private stream had at the scope end. + /// Then it's placed into data + collected_restricted_stream_gens: RestrictedStreamGens, +} + +struct StreamDescriptor { + pub(self) span: Span, + // TODO: get rid of RefCell in a separate PR + pub(self) stream: RefCell, +} + +impl Streams { + pub(crate) fn get(&self, name: &str, position: usize) -> Option<&RefCell> { + self.streams + .get(name) + .map(|descriptors| find_closest(descriptors.iter(), position)) + .flatten() + } + + pub(crate) fn add_stream_value( + &mut self, + value: ValueAggregate, + generation: Generation, + stream_name: &str, + position: usize, + ) -> ExecutionResult { + match self.get(stream_name, position) { + Some(stream) => stream.borrow_mut().add_value(value, generation), + None => { + // streams could be created in three ways: + // - after met new instruction with stream name that isn't present in streams + // (it's the only way to create restricted streams) + // - by calling add_global_stream with generation that come from data + // for global streams + // - and by this function, and if there is no such a streams in streams, + // it means that a new global one should be created. + let stream = Stream::from_value(value); + self.add_global_stream(stream_name.to_string(), stream); + let generation = 0; + Ok(generation) + } + } + } + + pub(crate) fn add_global_stream(&mut self, name: String, stream: Stream) { + let descriptor = StreamDescriptor::global(RefCell::new(stream)); + self.streams.insert(name, vec![descriptor]); + } + + pub(crate) fn meet_scope_start(&mut self, name: impl Into, span: Span, iteration: u32) { + let name = name.into(); + let generations_count = self + .stream_generation_from_data(&name, span.left as u32, iteration as usize) + .unwrap_or_default(); + + let new_stream = RefCell::new(Stream::from_generations_count(generations_count as usize)); + let new_descriptor = StreamDescriptor::restricted(new_stream, span); + match self.streams.entry(name) { + Occupied(mut entry) => { + entry.get_mut().push(new_descriptor); + } + Vacant(entry) => { + entry.insert(vec![new_descriptor]); + } + } + } + + pub(crate) fn meet_scope_end(&mut self, name: String, position: u32) { + // unwraps are safe here because met_scope_end must be called after met_scope_start + let stream_descriptors = self.streams.get_mut(&name).unwrap(); + // delete a stream after exit from a scope + let last_descriptor = stream_descriptors.pop().unwrap(); + if stream_descriptors.is_empty() { + // streams should contain only non-empty stream embodiments + self.streams.remove(&name); + } + + self.collect_stream_generation( + name, + position, + last_descriptor.stream.borrow().generations_count() as u32, + ); + } + + /// This method must be called at the end of execution, because it contains logic to collect + /// all global streams depending on their presence in a streams field. + pub(crate) fn into_streams_data(self) -> (GlobalStreamGens, RestrictedStreamGens) { + // since it's called at the end of execution, streams contains only global ones, + // because all private's been deleted after exiting a scope + let global_streams = self + .streams + .into_iter() + .map(|(name, mut descriptors)| { + // unwrap is safe here because of invariant that streams contains non-empty vectors, + // moreover it must contain only one value, because this method is called at the end + // of the execution + let generation = descriptors.pop().unwrap().stream.borrow().generations_count(); + (name, generation as u32) + }) + .collect::(); + + (global_streams, self.collected_restricted_stream_gens) + } + + fn stream_generation_from_data(&self, name: &str, position: u32, iteration: usize) -> Option { + self.data_restr_stream_generations + .get(name) + .and_then(|scopes| { + scopes + .get(&position) + .map(|iterations| iterations.get(iteration)) + .flatten() + }) + .copied() + } + + fn collect_stream_generation(&mut self, name: String, position: u32, generation: u32) { + match self.collected_restricted_stream_gens.entry(name) { + Occupied(mut streams) => match streams.get_mut().entry(position) { + Occupied(mut iterations) => iterations.get_mut().push(generation), + Vacant(entry) => { + entry.insert(vec![generation]); + } + }, + Vacant(entry) => { + let iterations = maplit::hashmap! { + position => vec![generation], + }; + entry.insert(iterations); + } + } + } +} + +impl StreamDescriptor { + pub(self) fn global(stream: RefCell) -> Self { + Self { + span: Span::new(0, usize::MAX), + stream, + } + } + + pub(self) fn restricted(stream: RefCell, span: Span) -> Self { + Self { span, stream } + } +} + +fn find_closest<'d>( + descriptors: impl DoubleEndedIterator, + position: usize, +) -> Option<&'d RefCell> { + // descriptors are placed in a order of decreasing scopes, so it's enough to get the latest suitable + for descriptor in descriptors.rev() { + if descriptor.span.contains(position) { + return Some(&descriptor.stream); + } + } + + None +} + +use air_parser::ast::Span; +use std::fmt; + +impl fmt::Display for Streams { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for (name, descriptors) in self.streams.iter() { + if let Some(last_descriptor) = descriptors.last() { + writeln!(f, "{} => {}", name, last_descriptor)?; + } + } + Ok(()) + } +} + +impl fmt::Display for StreamDescriptor { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + " <{}> - <{}>: {}", + self.span.left, + self.span.right, + self.stream.borrow() + ) + } +} diff --git a/air/src/execution_step/utils/resolve.rs b/air/src/execution_step/utils/resolve.rs index f6505a5d..9dc1cf21 100644 --- a/air/src/execution_step/utils/resolve.rs +++ b/air/src/execution_step/utils/resolve.rs @@ -87,9 +87,13 @@ pub(crate) fn resolve_variable<'ctx, 'i>( use crate::execution_step::boxed_value::StreamJvaluableIngredients; match variable { - Variable::Scalar(name) => Ok(ctx.scalars.get(name)?.into_jvaluable()), - Variable::Stream { name, generation } => { - match ctx.streams.get(name) { + Variable::Scalar { name, .. } => Ok(ctx.scalars.get(name)?.into_jvaluable()), + Variable::Stream { + name, + generation, + position, + } => { + match ctx.streams.get(name, position) { Some(stream) => { let ingredients = StreamJvaluableIngredients::new(stream.borrow(), generation); Ok(Box::new(ingredients)) diff --git a/air/src/preparation_step/preparation.rs b/air/src/preparation_step/preparation.rs index b3ba70fe..5cdcc568 100644 --- a/air/src/preparation_step/preparation.rs +++ b/air/src/preparation_step/preparation.rs @@ -88,13 +88,10 @@ fn make_exec_ctx( } fn create_streams(ctx: &mut ExecutionCtx<'_>, prev_data: &InterpreterData) { - use std::cell::RefCell; - - for (stream_name, generation_count) in prev_data.streams.iter() { + for (stream_name, generation_count) in prev_data.global_streams.iter() { let new_stream = Stream::from_generations_count(*generation_count as usize); - let new_stream = RefCell::new(new_stream); // it's impossible to have duplicates of streams in data because of HashMap in data - ctx.streams.insert(stream_name.to_string(), new_stream); + ctx.streams.add_global_stream(stream_name.to_string(), new_stream); } } diff --git a/air/src/runner/outcome.rs b/air/src/runner/outcome.rs index 0467c7bc..c0d111b5 100644 --- a/air/src/runner/outcome.rs +++ b/air/src/runner/outcome.rs @@ -16,28 +16,25 @@ use crate::execution_step::ExecutionCtx; use crate::execution_step::ExecutionError; -use crate::execution_step::Stream; use crate::execution_step::TraceHandler; use crate::preparation_step::PreparationError; use crate::InterpreterOutcome; use crate::INTERPRETER_SUCCESS; use air_interpreter_data::InterpreterData; -use air_interpreter_data::StreamGenerations; use air_interpreter_interface::CallRequests; -use std::cell::RefCell; -use std::collections::HashMap; use std::hash::Hash; use std::rc::Rc; /// Create InterpreterOutcome from supplied execution context and trace handler, /// set ret_code to INTERPRETER_SUCCESS. pub(crate) fn from_success_result(exec_ctx: ExecutionCtx<'_>, trace_handler: TraceHandler) -> InterpreterOutcome { - let streams = extract_stream_generations(exec_ctx.streams); + let (global_streams, restricted_streams) = exec_ctx.streams.into_streams_data(); let data = InterpreterData::from_execution_result( trace_handler.into_result_trace(), - streams, + global_streams, + restricted_streams, exec_ctx.last_call_request_id, ); let data = serde_json::to_vec(&data).expect("default serializer shouldn't fail"); @@ -94,10 +91,11 @@ pub(crate) fn from_execution_error( ) -> InterpreterOutcome { let ret_code = err.to_error_code() as i32; - let streams = extract_stream_generations(exec_ctx.streams); + let (global_streams, restricted_streams) = exec_ctx.streams.into_streams_data(); let data = InterpreterData::from_execution_result( trace_handler.into_result_trace(), - streams, + global_streams, + restricted_streams, exec_ctx.last_call_request_id, ); let data = serde_json::to_vec(&data).expect("default serializer shouldn't fail"); @@ -120,10 +118,3 @@ fn dedup(mut vec: Vec) -> Vec { let set: HashSet<_> = vec.drain(..).collect(); set.into_iter().collect() } - -fn extract_stream_generations(streams: HashMap>) -> StreamGenerations { - streams - .into_iter() - .map(|(name, stream)| (name, stream.borrow().generations_count() as u32)) - .collect::<_>() -} diff --git a/air/tests/test_module/instructions/mod.rs b/air/tests/test_module/instructions/mod.rs index 62467ca0..751a5a63 100644 --- a/air/tests/test_module/instructions/mod.rs +++ b/air/tests/test_module/instructions/mod.rs @@ -19,6 +19,7 @@ mod call; mod fold; mod match_; mod mismatch; +mod new; mod par; mod seq; mod xor; diff --git a/air/tests/test_module/instructions/new.rs b/air/tests/test_module/instructions/new.rs new file mode 100644 index 00000000..17ca8b78 --- /dev/null +++ b/air/tests/test_module/instructions/new.rs @@ -0,0 +1,289 @@ +/* + * Copyright 2020 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use air_test_utils::prelude::*; + +#[test] +fn new_with_global_streams_seq() { + let set_variable_peer_id = "set_variable_peer_id"; + let local_vm_peer_id_1 = "local_vm_peer_id_1"; + let local_vm_peer_id_2 = "local_vm_peer_id_2"; + + let mut local_vm_1 = create_avm(echo_call_service(), local_vm_peer_id_1); + let mut local_vm_2 = create_avm(echo_call_service(), local_vm_peer_id_2); + + let variables_mapping = maplit::hashmap! { + "1".to_string() => json!(1), + "2".to_string() => json!(2), + }; + let mut set_variable_vm = create_avm(set_variables_call_service(variables_mapping), set_variable_peer_id); + + let script = format!( + r#" + (seq + (seq + (call "{0}" ("" "") ["1"] $stream) + (call "{0}" ("" "") ["2"] $stream) + ) + (fold $stream i + (seq + (new $stream + (seq + (seq + (call "{1}" ("" "") [i] $stream) + (next i) + ) + (call "{1}" ("" "") [$stream]) + ) + ) + (call "{2}" ("" "") [$stream]) + ) + ) + )"#, + set_variable_peer_id, local_vm_peer_id_1, local_vm_peer_id_2 + ); + + let result = checked_call_vm!(set_variable_vm, "", &script, "", ""); + let vm_1_result = checked_call_vm!(local_vm_1, "", &script, "", result.data); + let vm_2_result = checked_call_vm!(local_vm_2, "", &script, "", vm_1_result.data.clone()); + + let vm_1_result = checked_call_vm!(local_vm_1, "", &script, vm_1_result.data, vm_2_result.data.clone()); + let vm_2_result = checked_call_vm!(local_vm_2, "", script, vm_2_result.data, vm_1_result.data); + + let actual_trace = trace_from_result(&vm_2_result); + let expected_trace = vec![ + executed_state::stream_number(1, 0), + executed_state::stream_number(2, 0), + executed_state::fold(vec![ + executed_state::subtrace_lore(0, SubTraceDesc::new(3, 1), SubTraceDesc::new(7, 2)), + executed_state::subtrace_lore(1, SubTraceDesc::new(4, 1), SubTraceDesc::new(5, 2)), + ]), + executed_state::stream_number(1, 0), + executed_state::stream_number(2, 0), + executed_state::scalar(json!([2])), + executed_state::scalar(json!([1, 2])), + executed_state::scalar(json!([1])), + executed_state::scalar(json!([1, 2])), + ]; + assert_eq!(actual_trace, expected_trace); + + let data = data_from_result(&vm_2_result); + let actual_restricted_streams = data.restricted_streams; + let expected_restricted_streams = maplit::hashmap! { + "$stream".to_string() => maplit::hashmap! { + 282 => vec![1,1] + } + }; + assert_eq!(actual_restricted_streams, expected_restricted_streams); +} + +#[test] +fn several_restrictions() { + let vm_peer_id = "vm_peer_id"; + let mut vm = create_avm(echo_call_service(), vm_peer_id); + + let script = format!( + r#" + (new $stream + (seq + (new $stream + (call "{0}" ("" "") ["test"] $stream) + ) + (call "{0}" ("" "") [$stream]) + ) + )"#, + vm_peer_id + ); + + let result = checked_call_vm!(vm, "", script, "", ""); + + let actual_trace = trace_from_result(&result); + let expected_trace = vec![ + executed_state::stream_string("test", 0), + executed_state::scalar(json!([])), + ]; + assert_eq!(actual_trace, expected_trace); +} + +#[test] +fn check_influence_to_not_restricted() { + let vm_peer_id = "vm_peer_id"; + let mut vm = create_avm(echo_call_service(), vm_peer_id); + + let script = format!( + r#" + (seq + (new $a + (seq + (seq + (seq + (ap "push more" $a0) + (ap "push more" $a1) + ) + (ap "more" $a) + ) + (call "{0}" ("op" "identity") [$a] a-fix) + ) + ) + (seq + (seq + (call "{0}" ("callbackSrv" "response") [$a0]) ;; should be non-empty + (call "{0}" ("callbackSrv" "response") [$a1]) ;; should be non-empty + ) + (seq + (call "{0}" ("callbackSrv" "response") [$a]) ;; should be empty + (call "{0}" ("callbackSrv" "response") [a-fix]) ;; should be empty + ) + ) + ) + "#, + vm_peer_id + ); + + let result = checked_call_vm!(vm, "", script, "", ""); + print_trace(&result, "initial"); + + let actual_trace = trace_from_result(&result); + let expected_trace = vec![ + executed_state::ap(Some(0)), + executed_state::ap(Some(0)), + executed_state::ap(Some(0)), + executed_state::scalar(json!(["more"])), + executed_state::scalar(json!(["push more"])), + executed_state::scalar(json!(["push more"])), + executed_state::scalar(json!([])), + executed_state::scalar(json!(["more"])), + ]; + assert_eq!(actual_trace, expected_trace); +} + +#[test] +fn new_in_fold_with_ap() { + let set_variable_peer_id = "set_variable_peer_id"; + let vm_peer_id = "vm_peer_id"; + + let mut set_variable_vm = create_avm(set_variable_call_service(json!([1, 2, 3, 4, 5])), set_variable_peer_id); + let mut vm = create_avm(echo_call_service(), vm_peer_id); + + let script = format!( + r#" + (seq + (call "{0}" ("" "") [] iterable) + (fold iterable x + (seq + (new $s1 + (seq + (ap "none" $s1) + (call "{1}" ("" "") [$s1] s-fix1) ;; should contains only "none" on each iteration + ) + ) + (next x) + ) + ) + ) + + "#, + set_variable_peer_id, vm_peer_id + ); + + let result = checked_call_vm!(set_variable_vm, "", &script, "", ""); + let result = checked_call_vm!(vm, "", script, "", result.data); + + print_trace(&result, "initial"); + + let actual_trace = trace_from_result(&result); + let expected_trace = vec![ + executed_state::scalar(json!([1, 2, 3, 4, 5])), + executed_state::ap(Some(0)), + executed_state::scalar_string_array(vec!["none"]), + executed_state::ap(Some(0)), + executed_state::scalar_string_array(vec!["none"]), + executed_state::ap(Some(0)), + executed_state::scalar_string_array(vec!["none"]), + executed_state::ap(Some(0)), + executed_state::scalar_string_array(vec!["none"]), + executed_state::ap(Some(0)), + executed_state::scalar_string_array(vec!["none"]), + ]; + assert_eq!(actual_trace, expected_trace); + + let data = data_from_result(&result); + let actual_restricted_streams = data.restricted_streams; + let expected_restricted_streams = maplit::hashmap! { + "$s1".to_string() => maplit::hashmap! { + 146 => vec![1,1,1,1,1] + } + }; + assert_eq!(actual_restricted_streams, expected_restricted_streams); +} + +#[test] +fn new_with_errors() { + let faillible_peer_id = "failible_peer_id"; + let mut faillible_vm = create_avm(fallible_call_service("service_id_1"), faillible_peer_id); + + let local_peer_id = "local_peer_id"; + let mut vm = create_avm(echo_call_service(), local_peer_id); + + let script = format!( + r#" + (seq + (call "{0}" ("" "") [1] $global_stream) ;; this stream should precense in a data + (new $restricted_stream_1 + (seq + (new $restricted_stream_2 + (seq + (call "{0}" ("" "") [2] $restricted_stream_2) ;; should have generation 1 in a data + (call "{1}" ("service_id_1" "local_fn_name") [] result) + ) + ) + (call "{0}" ("" "") [2] restricted_stream_1) ;; should have generation 0 in a data + ) + ) + )"#, + local_peer_id, faillible_peer_id + ); + + let result = checked_call_vm!(vm, "", &script, "", ""); + let result = call_vm!(faillible_vm, "", script, "", result.data); + + let actual_trace = trace_from_result(&result); + let expected_trace = vec![ + executed_state::stream_number(1, 0), + executed_state::stream_number(2, 0), + executed_state::service_failed(1, r#""error""#), + ]; + assert_eq!(actual_trace, expected_trace); + + let data = data_from_result(&result); + + let actual_restricted_streams = data.restricted_streams; + let expected_restricted_streams = maplit::hashmap! { + "$restricted_stream_2".to_string() => maplit::hashmap! { + 216 => vec![1] + }, + "$restricted_stream_1".to_string() => maplit::hashmap! { + 141 => vec![0] + } + }; + assert_eq!(actual_restricted_streams, expected_restricted_streams); + + let actual_global_streams = data.global_streams; + let expected_global_streams = maplit::hashmap! { + "$global_stream".to_string() => 1, + }; + assert_eq!(actual_global_streams, expected_global_streams); +} diff --git a/air/tests/test_module/integration/data_merge.rs b/air/tests/test_module/integration/data_merge.rs index fdba4af5..eb7c5a82 100644 --- a/air/tests/test_module/integration/data_merge.rs +++ b/air/tests/test_module/integration/data_merge.rs @@ -262,13 +262,13 @@ fn fold_merge() { let data = InterpreterData::try_from_slice(&result_7.data).expect("data should be well-formed"); let stream_1_generations = data - .streams + .global_streams .get("$stream_1") - .expect("$stream_1 should presence in data"); + .expect("$stream_1 should be present in data"); let stream_2_generations = data - .streams + .global_streams .get("$stream_2") - .expect("$stream_2 should presence in data"); + .expect("$stream_2 should be present in data"); assert_eq!(*stream_1_generations, 4); assert_eq!(*stream_2_generations, 3); diff --git a/air/tests/test_module/integration/join.rs b/air/tests/test_module/integration/join.rs index 1c947668..18b0cd61 100644 --- a/air/tests/test_module/integration/join.rs +++ b/air/tests/test_module/integration/join.rs @@ -74,7 +74,7 @@ fn join_chat() { let remote_actual_trace = trace_from_result(&remote_result); let remote_expected_trace = vec![ executed_state::stream_string("test", 0), - executed_state::stream_jvalue(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), + executed_state::stream(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), executed_state::scalar(json!([["A", "Relay1"], ["B", "Relay2"]])), executed_state::par(1, 2), executed_state::request_sent_by("Remote"), @@ -97,7 +97,7 @@ fn join_chat() { let relay_1_expected_trace = vec![ executed_state::stream_string("test", 0), - executed_state::stream_jvalue(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), + executed_state::stream(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), executed_state::scalar(json!([["A", "Relay1"], ["B", "Relay2"]])), executed_state::par(2, 2), executed_state::stream_string("test", 0), @@ -115,7 +115,7 @@ fn join_chat() { let client_1_expected_trace = vec![ executed_state::stream_string("test", 0), - executed_state::stream_jvalue(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), + executed_state::stream(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), executed_state::scalar(json!([["A", "Relay1"], ["B", "Relay2"]])), executed_state::par(2, 2), executed_state::stream_string("test", 0), @@ -133,7 +133,7 @@ fn join_chat() { let relay_2_expected_trace = vec![ executed_state::stream_string("test", 0), - executed_state::stream_jvalue(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), + executed_state::stream(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), executed_state::scalar(json!([["A", "Relay1"], ["B", "Relay2"]])), executed_state::par(1, 3), executed_state::request_sent_by("Remote"), @@ -151,7 +151,7 @@ fn join_chat() { let client_2_expected_trace = vec![ executed_state::stream_string("test", 0), - executed_state::stream_jvalue(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), + executed_state::stream(json!([["A", "Relay1"], ["B", "Relay2"]]), 0), executed_state::scalar(json!([["A", "Relay1"], ["B", "Relay2"]])), executed_state::par(1, 3), executed_state::request_sent_by("Remote"), diff --git a/crates/air-lib/air-parser/src/ast/instructions.rs b/crates/air-lib/air-parser/src/ast/instructions.rs index a85c40ca..05e339f0 100644 --- a/crates/air-lib/air-parser/src/ast/instructions.rs +++ b/crates/air-lib/air-parser/src/ast/instructions.rs @@ -24,7 +24,6 @@ use std::rc::Rc; #[allow(clippy::large_enum_variant)] // for Null and Error variants #[derive(Serialize, Debug, PartialEq)] pub enum Instruction<'i> { - Null(Null), Call(Call<'i>), Ap(Ap<'i>), Seq(Seq<'i>), @@ -34,7 +33,9 @@ pub enum Instruction<'i> { MisMatch(MisMatch<'i>), FoldScalar(FoldScalar<'i>), FoldStream(FoldStream<'i>), + New(New<'i>), Next(Next<'i>), + Null(Null), Error, } @@ -88,6 +89,7 @@ pub struct FoldScalar<'i> { #[serde(borrow)] pub iterator: Scalar<'i>, pub instruction: Rc>, + pub span: Span, } /// (fold stream_iterable iterator instruction) @@ -97,6 +99,7 @@ pub struct FoldStream<'i> { #[serde(borrow)] pub iterator: Scalar<'i>, pub instruction: Rc>, + pub span: Span, } /// (fold stream_iterable iterator instruction) @@ -105,6 +108,14 @@ pub struct Next<'i> { pub iterator: Scalar<'i>, } +/// (new variable instruction) +#[derive(Serialize, Debug, PartialEq)] +pub struct New<'i> { + pub variable: Variable<'i>, + pub instruction: Box>, + pub span: Span, +} + /// (null) #[derive(Serialize, Debug, PartialEq)] pub struct Null; diff --git a/crates/air-lib/air-parser/src/ast/instructions/impls.rs b/crates/air-lib/air-parser/src/ast/instructions/impls.rs index bfa38fc0..e79a0c54 100644 --- a/crates/air-lib/air-parser/src/ast/instructions/impls.rs +++ b/crates/air-lib/air-parser/src/ast/instructions/impls.rs @@ -21,3 +21,121 @@ impl<'i> Ap<'i> { Self { argument, result } } } + +impl<'i> Call<'i> { + pub fn new( + triplet: Triplet<'i>, + args: Rc>>, + output: CallOutputValue<'i>, + ) -> Self { + Self { + triplet, + args, + output, + } + } +} + +impl<'i> Seq<'i> { + pub fn new( + left_instruction: Box>, + right_instruction: Box>, + ) -> Self { + Self(left_instruction, right_instruction) + } +} + +impl<'i> Par<'i> { + pub fn new( + left_instruction: Box>, + right_instruction: Box>, + ) -> Self { + Self(left_instruction, right_instruction) + } +} + +impl<'i> Xor<'i> { + pub fn new( + left_instruction: Box>, + right_instruction: Box>, + ) -> Self { + Self(left_instruction, right_instruction) + } +} + +impl<'i> Match<'i> { + pub fn new( + left_value: Value<'i>, + right_value: Value<'i>, + instruction: Box>, + ) -> Self { + Self { + left_value, + right_value, + instruction, + } + } +} + +impl<'i> MisMatch<'i> { + pub fn new( + left_value: Value<'i>, + right_value: Value<'i>, + instruction: Box>, + ) -> Self { + Self { + left_value, + right_value, + instruction, + } + } +} + +impl<'i> FoldScalar<'i> { + pub fn new( + iterable: ScalarWithLambda<'i>, + iterator: Scalar<'i>, + instruction: Instruction<'i>, + span: Span, + ) -> Self { + Self { + iterable, + iterator, + instruction: Rc::new(instruction), + span, + } + } +} + +impl<'i> FoldStream<'i> { + pub fn new( + iterable: Stream<'i>, + iterator: Scalar<'i>, + instruction: Instruction<'i>, + span: Span, + ) -> Self { + Self { + iterable, + iterator, + instruction: Rc::new(instruction), + span, + } + } +} + +impl<'i> Next<'i> { + pub fn new(iterator: Scalar<'i>) -> Self { + Self { iterator } + } +} + +impl<'i> New<'i> { + #[allow(clippy::self_named_constructors)] + pub fn new(variable: Variable<'i>, instruction: Box>, span: Span) -> Self { + Self { + variable, + instruction, + span, + } + } +} diff --git a/crates/air-lib/air-parser/src/ast/instructions/traits.rs b/crates/air-lib/air-parser/src/ast/instructions/traits.rs index e7c5a0f0..3daa36d4 100644 --- a/crates/air-lib/air-parser/src/ast/instructions/traits.rs +++ b/crates/air-lib/air-parser/src/ast/instructions/traits.rs @@ -23,7 +23,6 @@ impl fmt::Display for Instruction<'_> { use Instruction::*; match self { - Null(null) => write!(f, "{}", null), Call(call) => write!(f, "{}", call), Ap(ap) => write!(f, "{}", ap), Seq(seq) => write!(f, "{}", seq), @@ -34,6 +33,8 @@ impl fmt::Display for Instruction<'_> { FoldScalar(fold) => write!(f, "{}", fold), FoldStream(fold) => write!(f, "{}", fold), Next(next) => write!(f, "{}", next), + New(new) => write!(f, "{}", new), + Null(null) => write!(f, "{}", null), Error => Ok(()), } } @@ -107,3 +108,9 @@ impl fmt::Display for Next<'_> { write!(f, "next") } } + +impl fmt::Display for New<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "new {}", self.variable) + } +} diff --git a/crates/air-lib/air-parser/src/ast/mod.rs b/crates/air-lib/air-parser/src/ast/mod.rs index ad41ab8a..515b5b8a 100644 --- a/crates/air-lib/air-parser/src/ast/mod.rs +++ b/crates/air-lib/air-parser/src/ast/mod.rs @@ -24,3 +24,4 @@ pub use values::*; pub use crate::parser::lexer::LastErrorPath; pub use crate::parser::lexer::Number; +pub use crate::parser::Span; diff --git a/crates/air-lib/air-parser/src/ast/values.rs b/crates/air-lib/air-parser/src/ast/values.rs index 10188e1e..3f161227 100644 --- a/crates/air-lib/air-parser/src/ast/values.rs +++ b/crates/air-lib/air-parser/src/ast/values.rs @@ -26,6 +26,7 @@ use serde::Serialize; #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)] pub struct Scalar<'i> { pub name: &'i str, + pub position: usize, } /// A scalar value with possible lambda expression. @@ -34,12 +35,14 @@ pub struct ScalarWithLambda<'i> { pub name: &'i str, #[serde(borrow)] pub lambda: Option>, + pub position: usize, } /// A stream without lambda. #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)] pub struct Stream<'i> { pub name: &'i str, + pub position: usize, } /// A stream with possible lambda expression. @@ -48,6 +51,7 @@ pub struct StreamWithLambda<'i> { pub name: &'i str, #[serde(borrow)] pub lambda: Option>, + pub position: usize, } /// A variable that could be either scalar or stream without lambda. diff --git a/crates/air-lib/air-parser/src/ast/values/impls.rs b/crates/air-lib/air-parser/src/ast/values/impls.rs index 0c81e141..31bedc48 100644 --- a/crates/air-lib/air-parser/src/ast/values/impls.rs +++ b/crates/air-lib/air-parser/src/ast/values/impls.rs @@ -19,55 +19,73 @@ use air_lambda_parser::LambdaAST; use air_lambda_parser::ValueAccessor; impl<'i> ScalarWithLambda<'i> { - pub fn new(name: &'i str, lambda: Option>) -> Self { - Self { name, lambda } + pub fn new(name: &'i str, lambda: Option>, position: usize) -> Self { + Self { + name, + lambda, + position, + } } // it's unsafe method that should be used only for tests - pub(crate) fn from_raw_lambda(name: &'i str, lambda: Vec>) -> Self { + pub(crate) fn from_raw_lambda( + name: &'i str, + lambda: Vec>, + position: usize, + ) -> Self { let lambda = unsafe { LambdaAST::new_unchecked(lambda) }; Self { name, lambda: Some(lambda), + position, } } } impl<'i> StreamWithLambda<'i> { - pub fn new(name: &'i str, lambda: Option>) -> Self { - Self { name, lambda } + pub fn new(name: &'i str, lambda: Option>, position: usize) -> Self { + Self { + name, + lambda, + position, + } } // it's unsafe method that should be used only for tests #[allow(dead_code)] - pub(crate) fn from_raw_lambda(name: &'i str, lambda: Vec>) -> Self { + pub(crate) fn from_raw_lambda( + name: &'i str, + lambda: Vec>, + position: usize, + ) -> Self { let lambda = unsafe { LambdaAST::new_unchecked(lambda) }; Self { name, lambda: Some(lambda), + position, } } } impl<'i> Scalar<'i> { - pub fn new(name: &'i str) -> Self { - Self { name } + pub fn new(name: &'i str, position: usize) -> Self { + Self { name, position } } } impl<'i> Stream<'i> { - pub fn new(name: &'i str) -> Self { - Self { name } + pub fn new(name: &'i str, position: usize) -> Self { + Self { name, position } } } impl<'i> Variable<'i> { - pub fn scalar(name: &'i str) -> Self { - Self::Scalar(Scalar { name }) + pub fn scalar(name: &'i str, position: usize) -> Self { + Self::Scalar(Scalar::new(name, position)) } - pub fn stream(name: &'i str) -> Self { - Self::Stream(Stream { name }) + pub fn stream(name: &'i str, position: usize) -> Self { + Self::Stream(Stream::new(name, position)) } pub fn name(&self) -> &str { @@ -79,26 +97,20 @@ impl<'i> Variable<'i> { } impl<'i> VariableWithLambda<'i> { - pub fn scalar(name: &'i str) -> Self { - Self::Scalar(ScalarWithLambda { name, lambda: None }) + pub fn scalar(name: &'i str, position: usize) -> Self { + Self::Scalar(ScalarWithLambda::new(name, None, position)) } - pub fn scalar_wl(name: &'i str, lambda: LambdaAST<'i>) -> Self { - Self::Scalar(ScalarWithLambda { - name, - lambda: Some(lambda), - }) + pub fn scalar_wl(name: &'i str, lambda: LambdaAST<'i>, position: usize) -> Self { + Self::Scalar(ScalarWithLambda::new(name, Some(lambda), position)) } - pub fn stream(name: &'i str) -> Self { - Self::Stream(StreamWithLambda { name, lambda: None }) + pub fn stream(name: &'i str, position: usize) -> Self { + Self::Stream(StreamWithLambda::new(name, None, position)) } - pub fn stream_wl(name: &'i str, lambda: LambdaAST<'i>) -> Self { - Self::Stream(StreamWithLambda { - name, - lambda: Some(lambda), - }) + pub fn stream_wl(name: &'i str, lambda: LambdaAST<'i>, position: usize) -> Self { + Self::Stream(StreamWithLambda::new(name, Some(lambda), position)) } pub fn name(&self) -> &str { @@ -117,15 +129,23 @@ impl<'i> VariableWithLambda<'i> { // This function is unsafe and lambda must be non-empty, although it's used only for tests #[allow(dead_code)] - pub(crate) fn from_raw_lambda_scalar(name: &'i str, lambda: Vec>) -> Self { - let scalar = ScalarWithLambda::from_raw_lambda(name, lambda); + pub(crate) fn from_raw_lambda_scalar( + name: &'i str, + lambda: Vec>, + position: usize, + ) -> Self { + let scalar = ScalarWithLambda::from_raw_lambda(name, lambda, position); Self::Scalar(scalar) } // This function is unsafe and lambda must be non-empty, although it's used only for tests #[allow(dead_code)] - pub(crate) fn from_raw_lambda_stream(name: &'i str, lambda: Vec>) -> Self { - let stream = StreamWithLambda::from_raw_lambda(name, lambda); + pub(crate) fn from_raw_lambda_stream( + name: &'i str, + lambda: Vec>, + position: usize, + ) -> Self { + let stream = StreamWithLambda::from_raw_lambda(name, lambda, position); Self::Stream(stream) } } diff --git a/crates/air-lib/air-parser/src/parser/air.lalrpop b/crates/air-lib/air-parser/src/parser/air.lalrpop index 78bde301..51223e7d 100644 --- a/crates/air-lib/air-parser/src/parser/air.lalrpop +++ b/crates/air-lib/air-parser/src/parser/air.lalrpop @@ -28,10 +28,11 @@ Instr: Box> = { } }; - let output = output.map(CallOutputValue::Variable).unwrap_or(CallOutputValue::None); let args = Rc::new(args); - let call = Call { triplet, args, output}; - let span = Span { left, right }; + let output = output.map(CallOutputValue::Variable).unwrap_or(CallOutputValue::None); + let call = Call::new(triplet, args, output); + let span = Span::new(left, right); + validator.met_call(&call, span); Box::new(Instruction::Call(call)) @@ -39,42 +40,51 @@ Instr: Box> = { "(" ap ")" => { let apply = Ap::new(arg, result); - let span = Span { left, right }; + + let span = Span::new(left, right); validator.met_ap(&apply, span); Box::new(Instruction::Ap(apply)) }, - "(" seq ")" => Box::new(Instruction::Seq(Seq(l, r))), - "(" par ")" => Box::new(Instruction::Par(Par(l, r))), + "(" seq ")" => Box::new(Instruction::Seq(Seq::new(l, r))), + "(" par ")" => Box::new(Instruction::Par(Par::new(l, r))), "(" null ")" => Box::new(Instruction::Null(Null)), - "(" fold ")" => { - let iterator = Scalar { name: iterator_name }; - let instruction = Rc::new(*i); - let fold = FoldScalar { iterable, iterator, instruction }; - let span = Span { left, right }; + "(" new ")" => { + let span = Span::new(left, right); + let new = New::new(variable, instruction, span); + + validator.met_new(&new, span); + + Box::new(Instruction::New(new)) + }, + + "(" fold ")" => { + let iterator = Scalar::new(iterator.0, iterator.1); + let span = Span::new(left, right); + let fold = FoldScalar::new(iterable, iterator, *i, span); + validator.met_fold_scalar(&fold, span); Box::new(Instruction::FoldScalar(fold)) }, - "(" fold ")" => { - let iterable = Stream { name: stream_name }; - let iterator = Scalar { name: iterator_name }; - let instruction = Rc::new(*i); - let fold = FoldStream { iterable, iterator, instruction }; + "(" fold ")" => { + let iterable = Stream::new(stream.0, stream.1); + let iterator = Scalar::new(iterator.0, iterator.1); + let span = Span::new(left, right); + let fold = FoldStream::new(iterable, iterator, *i, span); - let span = Span { left, right }; validator.meet_fold_stream(&fold, span); Box::new(Instruction::FoldStream(fold)) }, - "(" next ")" => { - let iterator = Scalar { name: iterator_name }; - let next = Next { iterator }; - let span = Span { left, right }; + "(" next ")" => { + let iterator = Scalar::new(iterator.0, iterator.1); + let next = Next::new(iterator); + let span = Span::new(left, right); validator.met_next(&next, span); Box::new(Instruction::Next(next)) @@ -83,16 +93,16 @@ Instr: Box> = { "(" xor ")" => Box::new(Instruction::Xor(Xor(l, r))), "(" match_ ")" => { - let match_ = Match { left_value: l, right_value: r, instruction: i}; - let span = Span { left, right }; + let match_ = Match::new(l, r, i); + let span = Span::new(left, right); validator.met_match(&match_, span); Box::new(Instruction::Match(match_)) }, "(" mismatch ")" => { - let mismatch = MisMatch { left_value: l, right_value: r, instruction: i}; - let span = Span { left, right }; + let mismatch = MisMatch::new(l, r, i); + let span = Span::new(left, right); validator.met_mismatch(&mismatch, span); Box::new(Instruction::MisMatch(mismatch)) @@ -119,13 +129,13 @@ ApResult = ScriptVariable; CallOutput = ScriptVariable; ScriptVariable: Variable<'input> = { - => Variable::scalar(scalar), - => Variable::stream(stream), + => Variable::scalar(scalar.0, scalar.1), + => Variable::stream(stream.0, stream.1), }; FoldScalarIterable: ScalarWithLambda<'input> = { - => ScalarWithLambda::new(scalar, None), - => ScalarWithLambda::new(scalar.0, Some(scalar.1)), + => ScalarWithLambda::new(scalar.0, None, scalar.1), + => ScalarWithLambda::new(scalar.0, Some(scalar.1), scalar.2), }; Function = CallInstrValue; @@ -135,10 +145,10 @@ ServiceId = CallInstrValue; CallInstrValue: CallInstrValue<'input> = { InitPeerId => CallInstrValue::InitPeerId, => CallInstrValue::Literal(l), - => CallInstrValue::Variable(VariableWithLambda::scalar(scalar)), - => CallInstrValue::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1)), - => CallInstrValue::Variable(VariableWithLambda::stream(stream)), - => CallInstrValue::Variable(VariableWithLambda::stream_wl(stream.0, stream.1)), + => CallInstrValue::Variable(VariableWithLambda::scalar(scalar.0, scalar.1)), + => CallInstrValue::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1, scalar.2)), + => CallInstrValue::Variable(VariableWithLambda::stream(stream.0, stream.1)), + => CallInstrValue::Variable(VariableWithLambda::stream_wl(stream.0, stream.1, stream.2)), } Arg = Value; @@ -150,10 +160,10 @@ Value: Value<'input> = { => Value::Number(n), => Value::Boolean(b), EmptyArray => Value::EmptyArray, - => Value::Variable(VariableWithLambda::scalar(scalar_name)), - => Value::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1)), - => Value::Variable(VariableWithLambda::stream(stream_name)), - => Value::Variable(VariableWithLambda::stream_wl(stream.0, stream.1)), + => Value::Variable(VariableWithLambda::scalar(scalar.0, scalar.1)), + => Value::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1, scalar.2)), + => Value::Variable(VariableWithLambda::stream(stream.0, stream.1)), + => Value::Variable(VariableWithLambda::stream_wl(stream.0, stream.1, stream.2)), } ApArgument: ApArgument<'input> = { @@ -163,8 +173,8 @@ ApArgument: ApArgument<'input> = { => ApArgument::Number(n), => ApArgument::Boolean(b), EmptyArray => ApArgument::EmptyArray, - => ApArgument::Scalar(ScalarWithLambda { name: scalar, lambda: None }), - => ApArgument::Scalar(ScalarWithLambda { name: scalar.0, lambda: Some(scalar.1) }), + => ApArgument::Scalar(ScalarWithLambda::new(scalar.0, None, scalar.1)), + => ApArgument::Scalar(ScalarWithLambda::new(scalar.0, Some(scalar.1), scalar.2)), } extern { @@ -179,10 +189,10 @@ extern { EmptyArray => Token::SquareBrackets, Literal => Token::StringLiteral(<&'input str>), - Scalar => Token::Scalar { name:<&'input str> }, - ScalarWithLambda => Token::ScalarWithLambda { name: <&'input str>, lambda: >}, - Stream => Token::Stream { name: <&'input str> }, - StreamWithLambda => Token::StreamWithLambda {name: <&'input str>, lambda:>}, + Scalar => Token::Scalar { name:<&'input str>, position: }, + ScalarWithLambda => Token::ScalarWithLambda { name: <&'input str>, lambda: >, position: }, + Stream => Token::Stream { name: <&'input str>, position: }, + StreamWithLambda => Token::StreamWithLambda {name: <&'input str>, lambda:>, position: }, Number => Token::Number(), Boolean => Token::Boolean(), @@ -193,10 +203,11 @@ extern { ap => Token::Ap, seq => Token::Seq, par => Token::Par, - null => Token::Null, fold => Token::Fold, xor => Token::Xor, + new => Token::New, next => Token::Next, + null => Token::Null, match_ => Token::Match, mismatch => Token::MisMatch, } diff --git a/crates/air-lib/air-parser/src/parser/air.rs b/crates/air-lib/air-parser/src/parser/air.rs index d8126013..0f144698 100644 --- a/crates/air-lib/air-parser/src/parser/air.rs +++ b/crates/air-lib/air-parser/src/parser/air.rs @@ -1,5 +1,5 @@ // auto-generated: "lalrpop 0.19.6" -// sha3: 47a2a31ea519d538c1c6dec9edc85aa26eff9f66cb8ce4556ca2b6ba91caece1 +// sha3: abe1e42a369b4cdc8b69ac7534dbe660e63d7624d7ed97b7c6983c96bfa9a129 use crate::ast::*; use crate::parser::ParserError; use crate::parser::VariableValidator; @@ -50,229 +50,238 @@ mod __parse__AIR { Variant2(LastErrorPath), Variant3(&'input str), Variant4(Number), - Variant5((&'input str, LambdaAST<'input>)), - Variant6(__lalrpop_util::ErrorRecovery, ParserError>), - Variant7(Value<'input>), - Variant8(alloc::vec::Vec>), - Variant9(usize), - Variant10(Box>), - Variant11(ApArgument<'input>), - Variant12(Variable<'input>), - Variant13(Vec>), - Variant14(CallInstrValue<'input>), - Variant15(core::option::Option>), - Variant16(FunctionPart<'input>), - Variant17(ScalarWithLambda<'input>), - Variant18(PeerPart<'input>), + Variant5((&'input str, usize)), + Variant6((&'input str, LambdaAST<'input>, usize)), + Variant7(__lalrpop_util::ErrorRecovery, ParserError>), + Variant8(Value<'input>), + Variant9(alloc::vec::Vec>), + Variant10(usize), + Variant11(Box>), + Variant12(ApArgument<'input>), + Variant13(Variable<'input>), + Variant14(Vec>), + Variant15(CallInstrValue<'input>), + Variant16(core::option::Option>), + Variant17(FunctionPart<'input>), + Variant18(ScalarWithLambda<'input>), + Variant19(PeerPart<'input>), } const __ACTION: &[i8] = &[ // State 0 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 1 - 0, 0, 0, 0, 35, 36, 37, 38, 39, 40, 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 37, 38, 39, 40, 41, 42, 43, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 2 - 12, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 3 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 53, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 55, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 4 - 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 5 - 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 6 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 7 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 8 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 9 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 10 - 19, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 11 - 0, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 12 - 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 13 - 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 14 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 0, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 15 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 16 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 17 - 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 18 - 0, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 19 - 0, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 20 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 21 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 22 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 23 - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 24 - 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 25 - 0, 0, 0, 92, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, // State 26 - 0, 0, 0, 0, 0, 0, 45, 0, 46, 0, 47, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 27 - 0, 0, 0, 101, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 96, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 28 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 47, 0, 48, 0, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 29 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 105, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 30 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 33, 34, 7, 8, 9, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 31 - -47, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 32 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 7, 35, 36, 8, 9, 10, 0, // State 33 - 0, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -48, // State 34 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, 0, -13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 35 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 36 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -9, 0, -9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, 0, -13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 37 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10, 0, -10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 38 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11, 0, -11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -9, 0, -9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 39 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -12, 0, -12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -10, 0, -10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 40 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11, 0, -11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 41 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, 0, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -12, 0, -12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 42 - -48, 0, 0, 0, 0, 0, -48, 0, -48, 0, -48, -48, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 43 - -49, 0, 0, 0, 0, 0, -49, 0, -49, 0, -49, -49, -49, -49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, 0, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 44 - -21, -21, -21, 0, 0, 0, -21, 0, -21, 0, -21, -21, -21, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -49, 0, 0, 0, 0, 0, -49, 0, -49, 0, -49, -49, -49, -49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 45 - -22, -22, -22, 0, 0, 0, -22, 0, -22, 0, -22, -22, -22, -22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -50, 0, 0, 0, 0, 0, -50, 0, -50, 0, -50, -50, -50, -50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 46 - -23, -23, -23, 0, 0, 0, -23, 0, -23, 0, -23, -23, -23, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -21, -21, -21, 0, 0, 0, -21, 0, -21, 0, -21, -21, -21, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 47 - -24, -24, -24, 0, 0, 0, -24, 0, -24, 0, -24, -24, -24, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -22, -22, -22, 0, 0, 0, -22, 0, -22, 0, -22, -22, -22, -22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 48 - -25, -25, -25, 0, 0, 0, -25, 0, -25, 0, -25, -25, -25, -25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -23, -23, -23, 0, 0, 0, -23, 0, -23, 0, -23, -23, -23, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 49 - -26, -26, -26, 0, 0, 0, -26, 0, -26, 0, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -24, -24, -24, 0, 0, 0, -24, 0, -24, 0, -24, -24, -24, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 50 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -25, -25, -25, 0, 0, 0, -25, 0, -25, 0, -25, -25, -25, -25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 51 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -26, -26, -26, 0, 0, 0, -26, 0, -26, 0, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 52 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 53 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 54 - -58, 0, 0, -58, -58, -58, -58, -58, -58, -58, -58, -58, -58, -58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -58, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 55 - -59, 0, 0, -59, -59, -59, -59, -59, -59, -59, -59, -59, -59, -59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -59, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 56 - -54, 0, 0, -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -54, + -59, 0, 0, -59, -59, -59, -59, -59, -59, -59, -59, -59, -59, -59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -59, // State 57 - -55, 0, 0, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -55, + -60, 0, 0, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -60, // State 58 - -56, 0, 0, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -56, + -55, 0, 0, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -55, // State 59 - -57, 0, 0, -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -57, + -56, 0, 0, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -56, // State 60 - -60, 0, 0, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -60, + -57, 0, 0, -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -57, // State 61 - -61, 0, 0, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -61, + -58, 0, 0, -58, -58, -58, -58, -58, -58, -58, -58, -58, -58, -58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -58, // State 62 - -62, 0, 0, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -62, + -61, 0, 0, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -61, // State 63 - -63, 0, 0, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -63, + -62, 0, 0, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -62, // State 64 - 0, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -63, 0, 0, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -63, // State 65 - -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, + -64, 0, 0, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -64, // State 66 - 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -52, -52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -52, // State 67 - 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -53, -53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -53, // State 68 - 0, -51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 69 - 0, -52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, // State 70 - 0, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 71 - 0, 0, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 72 - -43, -43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -43, + 0, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 73 - 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 74 - 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 75 - 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -44, -44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -44, // State 76 - -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -37, + 0, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 77 - 0, -53, 0, 0, 0, 0, -53, 0, -53, 0, -53, -53, -53, -53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 78 - 0, 94, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 79 - 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -37, // State 80 - 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -54, 0, 0, 0, 0, -54, 0, -54, 0, -54, -54, -54, -54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 81 - 0, 97, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 82 - 0, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 83 - -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -39, + 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 84 - -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, + 0, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 85 - -44, -44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -44, + 0, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 86 - 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -41, // State 87 - 0, -27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -39, // State 88 - -36, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -36, + -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, // State 89 - 0, 0, 0, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -45, -45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -45, // State 90 - 0, 0, 0, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 91 - 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, -19, 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 92 - 0, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -36, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -36, // State 93 - -50, 0, 0, 0, 0, 0, -50, 0, -50, 0, -50, -50, -50, -50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 94 - -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -41, + 0, 0, 0, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 95 - -42, -42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -42, + 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, -19, 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 96 - -45, -45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -45, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 97 - -46, -46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -46, + -51, 0, 0, 0, 0, 0, -51, 0, -51, 0, -51, -51, -51, -51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // State 98 - -35, -35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -35, + -42, -42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -42, // State 99 - 0, 0, 0, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -43, -43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -43, // State 100 - 0, -20, 0, 0, 0, 0, 0, 0, 0, 0, -20, 0, -20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -46, -46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -46, // State 101 - 0, 0, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -47, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, + // State 102 + -35, -35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -35, + // State 103 + 0, 0, 0, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + // State 104 + 0, -20, 0, 0, 0, 0, 0, 0, 0, 0, -20, 0, -20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + // State 105 + 0, 0, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ]; fn __action(state: i8, integer: usize) -> i8 { - __ACTION[(state as usize) * 25 + integer] + __ACTION[(state as usize) * 26 + integer] } const __EOF_ACTION: &[i8] = &[ // State 0 @@ -332,17 +341,17 @@ mod __parse__AIR { // State 27 0, // State 28 - -64, - // State 29 - -8, - // State 30 0, + // State 29 + 0, + // State 30 + -65, // State 31 - -47, + -8, // State 32 0, // State 33 - 0, + -48, // State 34 0, // State 35 @@ -406,7 +415,7 @@ mod __parse__AIR { // State 64 0, // State 65 - -40, + 0, // State 66 0, // State 67 @@ -414,27 +423,27 @@ mod __parse__AIR { // State 68 0, // State 69 - 0, + -40, // State 70 0, // State 71 0, // State 72 - -43, + 0, // State 73 0, // State 74 0, // State 75 - 0, + -44, // State 76 - -37, + 0, // State 77 0, // State 78 0, // State 79 - 0, + -37, // State 80 0, // State 81 @@ -442,99 +451,109 @@ mod __parse__AIR { // State 82 0, // State 83 - -39, + 0, // State 84 - -38, + 0, // State 85 - -44, + 0, // State 86 - 0, + -41, // State 87 - 0, + -39, // State 88 - -36, + -38, // State 89 - 0, + -45, // State 90 0, // State 91 0, // State 92 - 0, + -36, // State 93 0, // State 94 - -41, + 0, // State 95 - -42, + 0, // State 96 - -45, + 0, // State 97 - -46, + 0, // State 98 - -35, + -42, // State 99 - 0, + -43, // State 100 - 0, + -46, // State 101 + -47, + // State 102 + -35, + // State 103 + 0, + // State 104 + 0, + // State 105 0, ]; fn __goto(state: i8, nt: usize) -> i8 { match nt { - 2 => 27, - 5 => 28, - 6 => 9, - 7 => 66, + 2 => 29, + 5 => 30, + 6 => 10, + 7 => 70, 8 => match state { - 27 => 99, - _ => 89, + 29 => 103, + _ => 93, }, - 9 => 24, + 9 => 26, 10 => match state { - 10 | 26 => 70, - 18..=19 => 77, - _ => 42, + 11 | 28 => 72, + 20..=21 => 80, + _ => 44, }, - 11 => 86, - 13 => 17, - 14 => 50, + 11 => 90, + 13 => 19, + 14 => 52, 15 => match state { - 26 => 92, - _ => 71, + 28 => 96, + _ => 73, }, 16 => match state { - 7 => 15, - 8 => 16, - 0 => 29, - 14 => 73, + 8 => 17, + 9 => 18, + 0 => 31, 15 => 74, - 16 => 75, - 20 => 79, - 21 => 80, - 22 => 81, - 23 => 82, - _ => 14, + 16 => 76, + 17 => 77, + 18 => 78, + 22 => 82, + 23 => 83, + 24 => 84, + 25 => 85, + _ => 16, }, 17 => match state { - 2 => 43, - _ => 19, + 2 => 45, + _ => 21, }, - 18 => 10, + 18 => 11, 19 => match state { - 24 => 87, - _ => 67, + 10 => 71, + 26 => 91, + _ => 15, }, 20 => match state { - 19 => 78, - _ => 26, + 21 => 81, + _ => 28, }, 21 => match state { - 4 => 12, - 5 => 13, - 12 => 22, - 13 => 23, - _ => 90, + 4 => 13, + 5 => 14, + 13 => 24, + 14 => 25, + _ => 94, }, _ => 0, } @@ -560,6 +579,7 @@ mod __parse__AIR { r###"fold"###, r###"match_"###, r###"mismatch"###, + r###"new"###, r###"next"###, r###"null"###, r###"par"###, @@ -619,7 +639,7 @@ mod __parse__AIR { #[inline] fn error_action(&self, state: i8) -> i8 { - __action(state, 25 - 1) + __action(state, 26 - 1) } #[inline] @@ -650,7 +670,7 @@ mod __parse__AIR { &self, recovery: __state_machine::ErrorRecovery, ) -> Self::Symbol { - __Symbol::Variant6(recovery) + __Symbol::Variant7(recovery) } fn reduce( @@ -696,20 +716,21 @@ mod __parse__AIR { Token::LastError(_) if true => Some(7), Token::StringLiteral(_) if true => Some(8), Token::Number(_) if true => Some(9), - Token::Scalar { name: _ } if true => Some(10), - Token::ScalarWithLambda { name: _, lambda: _ } if true => Some(11), - Token::Stream { name: _ } if true => Some(12), - Token::StreamWithLambda { name: _, lambda: _ } if true => Some(13), + Token::Scalar { name: _, position: _ } if true => Some(10), + Token::ScalarWithLambda { name: _, lambda: _, position: _ } if true => Some(11), + Token::Stream { name: _, position: _ } if true => Some(12), + Token::StreamWithLambda { name: _, lambda: _, position: _ } if true => Some(13), Token::Ap if true => Some(14), Token::Call if true => Some(15), Token::Fold if true => Some(16), Token::Match if true => Some(17), Token::MisMatch if true => Some(18), - Token::Next if true => Some(19), - Token::Null if true => Some(20), - Token::Par if true => Some(21), - Token::Seq if true => Some(22), - Token::Xor if true => Some(23), + Token::New if true => Some(19), + Token::Next if true => Some(20), + Token::Null if true => Some(21), + Token::Par if true => Some(22), + Token::Seq if true => Some(23), + Token::Xor if true => Some(24), _ => None, } } @@ -724,7 +745,7 @@ mod __parse__AIR { ) -> __Symbol<'input> { match __token_index { - 0 | 1 | 2 | 3 | 5 | 6 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 => __Symbol::Variant0(__token), + 0 | 1 | 2 | 3 | 5 | 6 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 => __Symbol::Variant0(__token), 4 => match __token { Token::Boolean(__tok0) if true => __Symbol::Variant1(__tok0), _ => unreachable!(), @@ -733,16 +754,20 @@ mod __parse__AIR { Token::LastError(__tok0) if true => __Symbol::Variant2(__tok0), _ => unreachable!(), }, - 8 | 10 | 12 => match __token { - Token::StringLiteral(__tok0) | Token::Scalar { name: __tok0 } | Token::Stream { name: __tok0 } if true => __Symbol::Variant3(__tok0), + 8 => match __token { + Token::StringLiteral(__tok0) if true => __Symbol::Variant3(__tok0), _ => unreachable!(), }, 9 => match __token { Token::Number(__tok0) if true => __Symbol::Variant4(__tok0), _ => unreachable!(), }, + 10 | 12 => match __token { + Token::Scalar { name: __tok0, position: __tok1 } | Token::Stream { name: __tok0, position: __tok1 } if true => __Symbol::Variant5((__tok0, __tok1)), + _ => unreachable!(), + }, 11 | 13 => match __token { - Token::ScalarWithLambda { name: __tok0, lambda: __tok1 } | Token::StreamWithLambda { name: __tok0, lambda: __tok1 } if true => __Symbol::Variant5((__tok0, __tok1)), + Token::ScalarWithLambda { name: __tok0, lambda: __tok1, position: __tok2 } | Token::StreamWithLambda { name: __tok0, lambda: __tok1, position: __tok2 } if true => __Symbol::Variant6((__tok0, __tok1, __tok2)), _ => unreachable!(), }, _ => unreachable!(), @@ -1003,7 +1028,7 @@ mod __parse__AIR { } 40 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 6, + states_to_pop: 5, nonterminal_produced: 16, } } @@ -1015,19 +1040,19 @@ mod __parse__AIR { } 42 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 4, + states_to_pop: 6, nonterminal_produced: 16, } } 43 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 5, + states_to_pop: 4, nonterminal_produced: 16, } } 44 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 6, + states_to_pop: 5, nonterminal_produced: 16, } } @@ -1039,32 +1064,32 @@ mod __parse__AIR { } 46 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 1, + states_to_pop: 6, nonterminal_produced: 16, } } 47 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, - nonterminal_produced: 17, + nonterminal_produced: 16, } } 48 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, - nonterminal_produced: 18, + nonterminal_produced: 17, } } 49 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 4, + states_to_pop: 1, nonterminal_produced: 18, } } 50 => { __state_machine::SimulatedReduce::Reduce { - states_to_pop: 1, - nonterminal_produced: 19, + states_to_pop: 4, + nonterminal_produced: 18, } } 51 => { @@ -1076,13 +1101,13 @@ mod __parse__AIR { 52 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, - nonterminal_produced: 20, + nonterminal_produced: 19, } } 53 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, - nonterminal_produced: 21, + nonterminal_produced: 20, } } 54 => { @@ -1139,7 +1164,13 @@ mod __parse__AIR { nonterminal_produced: 21, } } - 63 => __state_machine::SimulatedReduce::Accept, + 63 => { + __state_machine::SimulatedReduce::Reduce { + states_to_pop: 1, + nonterminal_produced: 21, + } + } + 64 => __state_machine::SimulatedReduce::Accept, _ => panic!("invalid reduction index {}", __reduce_index) } } @@ -1426,8 +1457,11 @@ mod __parse__AIR { __reduce62(input, errors, validator, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &(), &())>) } 63 => { + __reduce63(input, errors, validator, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &(), &())>) + } + 64 => { // __AIR = AIR => ActionFn(0); - let __sym0 = __pop_Variant10(__symbols); + let __sym0 = __pop_Variant11(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action0::<>(input, errors, validator, __sym0); @@ -1446,58 +1480,69 @@ mod __parse__AIR { fn __symbol_type_mismatch() -> ! { panic!("symbol type mismatch") } + fn __pop_Variant6< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, (&'input str, LambdaAST<'input>, usize), usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } fn __pop_Variant5< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, (&'input str, LambdaAST<'input>), usize) + ) -> (usize, (&'input str, usize), usize) { match __symbols.pop() { Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } + fn __pop_Variant12< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, ApArgument<'input>, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant12(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } fn __pop_Variant11< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, ApArgument<'input>, usize) + ) -> (usize, Box>, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant11(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant10< - 'input, - >( - __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, Box>, usize) - { - match __symbols.pop() { - Some((__l, __Symbol::Variant10(__v), __r)) => (__l, __v, __r), - _ => __symbol_type_mismatch() - } - } - fn __pop_Variant14< + fn __pop_Variant15< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, CallInstrValue<'input>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant14(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant15(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant16< + fn __pop_Variant17< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, FunctionPart<'input>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant16(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant17(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -1523,25 +1568,25 @@ mod __parse__AIR { _ => __symbol_type_mismatch() } } - fn __pop_Variant18< + fn __pop_Variant19< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, PeerPart<'input>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant18(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant19(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant17< + fn __pop_Variant18< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, ScalarWithLambda<'input>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant17(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant18(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -1556,25 +1601,14 @@ mod __parse__AIR { _ => __symbol_type_mismatch() } } - fn __pop_Variant7< + fn __pop_Variant8< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, Value<'input>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant7(__v), __r)) => (__l, __v, __r), - _ => __symbol_type_mismatch() - } - } - fn __pop_Variant12< - 'input, - >( - __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, Variable<'input>, usize) - { - match __symbols.pop() { - Some((__l, __Symbol::Variant12(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant8(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -1582,32 +1616,43 @@ mod __parse__AIR { 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, Vec>, usize) + ) -> (usize, Variable<'input>, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant13(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant6< + fn __pop_Variant14< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, Vec>, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant14(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant7< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, __lalrpop_util::ErrorRecovery, ParserError>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant7(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant8< + fn __pop_Variant9< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, alloc::vec::Vec>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant8(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant9(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -1622,25 +1667,25 @@ mod __parse__AIR { _ => __symbol_type_mismatch() } } - fn __pop_Variant15< + fn __pop_Variant16< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, core::option::Option>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant15(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant16(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant9< + fn __pop_Variant10< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, usize, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant9(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant10(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -1668,12 +1713,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // () = Arg => ActionFn(55); - let __sym0 = __pop_Variant7(__symbols); + // () = Arg => ActionFn(56); + let __sym0 = __pop_Variant8(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action55::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + let __nt = super::__action56::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 0) } pub(crate) fn __reduce1< @@ -1689,11 +1734,11 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ()* = => ActionFn(53); + // ()* = => ActionFn(54); let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); let __end = __start.clone(); - let __nt = super::__action53::<>(input, errors, validator, &__start, &__end); - __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + let __nt = super::__action54::<>(input, errors, validator, &__start, &__end); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); (0, 1) } pub(crate) fn __reduce2< @@ -1709,12 +1754,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ()* = ()+ => ActionFn(54); - let __sym0 = __pop_Variant8(__symbols); + // ()* = ()+ => ActionFn(55); + let __sym0 = __pop_Variant9(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action54::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + let __nt = super::__action55::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); (1, 1) } pub(crate) fn __reduce3< @@ -1730,12 +1775,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ()+ = Arg => ActionFn(62); - let __sym0 = __pop_Variant7(__symbols); + // ()+ = Arg => ActionFn(63); + let __sym0 = __pop_Variant8(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action62::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + let __nt = super::__action63::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); (1, 2) } pub(crate) fn __reduce4< @@ -1751,14 +1796,14 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ()+ = ()+, Arg => ActionFn(63); + // ()+ = ()+, Arg => ActionFn(64); assert!(__symbols.len() >= 2); - let __sym1 = __pop_Variant7(__symbols); - let __sym0 = __pop_Variant8(__symbols); + let __sym1 = __pop_Variant8(__symbols); + let __sym0 = __pop_Variant9(__symbols); let __start = __sym0.0.clone(); let __end = __sym1.2.clone(); - let __nt = super::__action63::<>(input, errors, validator, __sym0, __sym1); - __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + let __nt = super::__action64::<>(input, errors, validator, __sym0, __sym1); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); (2, 2) } pub(crate) fn __reduce5< @@ -1774,11 +1819,11 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // @L = => ActionFn(59); + // @L = => ActionFn(60); let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); let __end = __start.clone(); - let __nt = super::__action59::<>(input, errors, validator, &__start, &__end); - __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + let __nt = super::__action60::<>(input, errors, validator, &__start, &__end); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); (0, 3) } pub(crate) fn __reduce6< @@ -1794,11 +1839,11 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // @R = => ActionFn(56); + // @R = => ActionFn(57); let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); let __end = __start.clone(); - let __nt = super::__action56::<>(input, errors, validator, &__start, &__end); - __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + let __nt = super::__action57::<>(input, errors, validator, &__start, &__end); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); (0, 4) } pub(crate) fn __reduce7< @@ -1815,11 +1860,11 @@ mod __parse__AIR { ) -> (usize, usize) { // AIR = Instr => ActionFn(1); - let __sym0 = __pop_Variant10(__symbols); + let __sym0 = __pop_Variant11(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action1::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (1, 5) } pub(crate) fn __reduce8< @@ -1835,12 +1880,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = InitPeerId => ActionFn(45); + // ApArgument = InitPeerId => ActionFn(46); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action45::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action46::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce9< @@ -1856,12 +1901,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = LastError => ActionFn(46); + // ApArgument = LastError => ActionFn(47); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action46::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action47::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce10< @@ -1877,12 +1922,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = Literal => ActionFn(47); + // ApArgument = Literal => ActionFn(48); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action47::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action48::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce11< @@ -1898,12 +1943,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = Number => ActionFn(48); + // ApArgument = Number => ActionFn(49); let __sym0 = __pop_Variant4(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action48::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action49::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce12< @@ -1919,12 +1964,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = Boolean => ActionFn(49); + // ApArgument = Boolean => ActionFn(50); let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action49::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action50::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce13< @@ -1940,12 +1985,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = EmptyArray => ActionFn(50); + // ApArgument = EmptyArray => ActionFn(51); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action50::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action51::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce14< @@ -1961,12 +2006,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = Scalar => ActionFn(51); - let __sym0 = __pop_Variant3(__symbols); + // ApArgument = Scalar => ActionFn(52); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action51::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action52::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce15< @@ -1982,12 +2027,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApArgument = ScalarWithLambda => ActionFn(52); - let __sym0 = __pop_Variant5(__symbols); + // ApArgument = ScalarWithLambda => ActionFn(53); + let __sym0 = __pop_Variant6(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action52::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + let __nt = super::__action53::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant12(__nt), __end)); (1, 6) } pub(crate) fn __reduce16< @@ -2003,12 +2048,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ApResult = ScriptVariable => ActionFn(19); - let __sym0 = __pop_Variant12(__symbols); + // ApResult = ScriptVariable => ActionFn(20); + let __sym0 = __pop_Variant13(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action19::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant12(__nt), __end)); + let __nt = super::__action20::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant13(__nt), __end)); (1, 7) } pub(crate) fn __reduce17< @@ -2024,12 +2069,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Arg = Value => ActionFn(34); - let __sym0 = __pop_Variant7(__symbols); + // Arg = Value => ActionFn(35); + let __sym0 = __pop_Variant8(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action34::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + let __nt = super::__action35::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 8) } pub(crate) fn __reduce18< @@ -2045,14 +2090,14 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Args = "[", "]" => ActionFn(64); + // Args = "[", "]" => ActionFn(65); assert!(__symbols.len() >= 2); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym1.2.clone(); - let __nt = super::__action64::<>(input, errors, validator, __sym0, __sym1); - __symbols.push((__start, __Symbol::Variant13(__nt), __end)); + let __nt = super::__action65::<>(input, errors, validator, __sym0, __sym1); + __symbols.push((__start, __Symbol::Variant14(__nt), __end)); (2, 9) } pub(crate) fn __reduce19< @@ -2068,15 +2113,15 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Args = "[", ()+, "]" => ActionFn(65); + // Args = "[", ()+, "]" => ActionFn(66); assert!(__symbols.len() >= 3); let __sym2 = __pop_Variant0(__symbols); - let __sym1 = __pop_Variant8(__symbols); + let __sym1 = __pop_Variant9(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym2.2.clone(); - let __nt = super::__action65::<>(input, errors, validator, __sym0, __sym1, __sym2); - __symbols.push((__start, __Symbol::Variant13(__nt), __end)); + let __nt = super::__action66::<>(input, errors, validator, __sym0, __sym1, __sym2); + __symbols.push((__start, __Symbol::Variant14(__nt), __end)); (3, 9) } pub(crate) fn __reduce20< @@ -2092,12 +2137,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = InitPeerId => ActionFn(28); + // CallInstrValue = InitPeerId => ActionFn(29); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action28::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action29::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce21< @@ -2113,12 +2158,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = Literal => ActionFn(29); + // CallInstrValue = Literal => ActionFn(30); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action29::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action30::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce22< @@ -2134,12 +2179,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = Scalar => ActionFn(30); - let __sym0 = __pop_Variant3(__symbols); + // CallInstrValue = Scalar => ActionFn(31); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action30::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action31::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce23< @@ -2155,12 +2200,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = ScalarWithLambda => ActionFn(31); - let __sym0 = __pop_Variant5(__symbols); + // CallInstrValue = ScalarWithLambda => ActionFn(32); + let __sym0 = __pop_Variant6(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action31::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action32::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce24< @@ -2176,12 +2221,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = Stream => ActionFn(32); - let __sym0 = __pop_Variant3(__symbols); + // CallInstrValue = Stream => ActionFn(33); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action32::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action33::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce25< @@ -2197,12 +2242,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallInstrValue = StreamWithLambda => ActionFn(33); - let __sym0 = __pop_Variant5(__symbols); + // CallInstrValue = StreamWithLambda => ActionFn(34); + let __sym0 = __pop_Variant6(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action33::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action34::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 10) } pub(crate) fn __reduce26< @@ -2218,12 +2263,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallOutput = ScriptVariable => ActionFn(20); - let __sym0 = __pop_Variant12(__symbols); + // CallOutput = ScriptVariable => ActionFn(21); + let __sym0 = __pop_Variant13(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action20::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant12(__nt), __end)); + let __nt = super::__action21::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant13(__nt), __end)); (1, 11) } pub(crate) fn __reduce27< @@ -2239,12 +2284,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallOutput? = CallOutput => ActionFn(57); - let __sym0 = __pop_Variant12(__symbols); + // CallOutput? = CallOutput => ActionFn(58); + let __sym0 = __pop_Variant13(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action57::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant15(__nt), __end)); + let __nt = super::__action58::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant16(__nt), __end)); (1, 12) } pub(crate) fn __reduce28< @@ -2260,11 +2305,11 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // CallOutput? = => ActionFn(58); + // CallOutput? = => ActionFn(59); let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); let __end = __start.clone(); - let __nt = super::__action58::<>(input, errors, validator, &__start, &__end); - __symbols.push((__start, __Symbol::Variant15(__nt), __end)); + let __nt = super::__action59::<>(input, errors, validator, &__start, &__end); + __symbols.push((__start, __Symbol::Variant16(__nt), __end)); (0, 12) } pub(crate) fn __reduce29< @@ -2280,12 +2325,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // FPart = Function => ActionFn(15); - let __sym0 = __pop_Variant14(__symbols); + // FPart = Function => ActionFn(16); + let __sym0 = __pop_Variant15(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action15::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant16(__nt), __end)); + let __nt = super::__action16::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant17(__nt), __end)); (1, 13) } pub(crate) fn __reduce30< @@ -2301,16 +2346,16 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // FPart = "(", ServiceId, Function, ")" => ActionFn(16); + // FPart = "(", ServiceId, Function, ")" => ActionFn(17); assert!(__symbols.len() >= 4); let __sym3 = __pop_Variant0(__symbols); - let __sym2 = __pop_Variant14(__symbols); - let __sym1 = __pop_Variant14(__symbols); + let __sym2 = __pop_Variant15(__symbols); + let __sym1 = __pop_Variant15(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym3.2.clone(); - let __nt = super::__action16::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); - __symbols.push((__start, __Symbol::Variant16(__nt), __end)); + let __nt = super::__action17::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); + __symbols.push((__start, __Symbol::Variant17(__nt), __end)); (4, 13) } pub(crate) fn __reduce31< @@ -2326,12 +2371,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // FoldScalarIterable = Scalar => ActionFn(23); - let __sym0 = __pop_Variant3(__symbols); + // FoldScalarIterable = Scalar => ActionFn(24); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action23::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant17(__nt), __end)); + let __nt = super::__action24::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant18(__nt), __end)); (1, 14) } pub(crate) fn __reduce32< @@ -2347,12 +2392,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // FoldScalarIterable = ScalarWithLambda => ActionFn(24); - let __sym0 = __pop_Variant5(__symbols); + // FoldScalarIterable = ScalarWithLambda => ActionFn(25); + let __sym0 = __pop_Variant6(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action24::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant17(__nt), __end)); + let __nt = super::__action25::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant18(__nt), __end)); (1, 14) } pub(crate) fn __reduce33< @@ -2368,12 +2413,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Function = CallInstrValue => ActionFn(25); - let __sym0 = __pop_Variant14(__symbols); + // Function = CallInstrValue => ActionFn(26); + let __sym0 = __pop_Variant15(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action25::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); + let __nt = super::__action26::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); (1, 15) } pub(crate) fn __reduce34< @@ -2389,19 +2434,19 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", call, PeerPart, FPart, Args, CallOutput, ")" => ActionFn(80); + // Instr = "(", call, PeerPart, FPart, Args, CallOutput, ")" => ActionFn(83); assert!(__symbols.len() >= 7); let __sym6 = __pop_Variant0(__symbols); - let __sym5 = __pop_Variant12(__symbols); - let __sym4 = __pop_Variant13(__symbols); - let __sym3 = __pop_Variant16(__symbols); - let __sym2 = __pop_Variant18(__symbols); + let __sym5 = __pop_Variant13(__symbols); + let __sym4 = __pop_Variant14(__symbols); + let __sym3 = __pop_Variant17(__symbols); + let __sym2 = __pop_Variant19(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym6.2.clone(); - let __nt = super::__action80::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + let __nt = super::__action83::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (7, 16) } pub(crate) fn __reduce35< @@ -2417,18 +2462,18 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", call, PeerPart, FPart, Args, ")" => ActionFn(81); + // Instr = "(", call, PeerPart, FPart, Args, ")" => ActionFn(84); assert!(__symbols.len() >= 6); let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant13(__symbols); - let __sym3 = __pop_Variant16(__symbols); - let __sym2 = __pop_Variant18(__symbols); + let __sym4 = __pop_Variant14(__symbols); + let __sym3 = __pop_Variant17(__symbols); + let __sym2 = __pop_Variant19(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym5.2.clone(); - let __nt = super::__action81::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + let __nt = super::__action84::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (6, 16) } pub(crate) fn __reduce36< @@ -2444,17 +2489,17 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", ap, ApArgument, ApResult, ")" => ActionFn(74); + // Instr = "(", ap, ApArgument, ApResult, ")" => ActionFn(76); assert!(__symbols.len() >= 5); let __sym4 = __pop_Variant0(__symbols); - let __sym3 = __pop_Variant12(__symbols); - let __sym2 = __pop_Variant11(__symbols); + let __sym3 = __pop_Variant13(__symbols); + let __sym2 = __pop_Variant12(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym4.2.clone(); - let __nt = super::__action74::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + let __nt = super::__action76::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (5, 16) } pub(crate) fn __reduce37< @@ -2473,14 +2518,14 @@ mod __parse__AIR { // Instr = "(", seq, Instr, Instr, ")" => ActionFn(4); assert!(__symbols.len() >= 5); let __sym4 = __pop_Variant0(__symbols); - let __sym3 = __pop_Variant10(__symbols); - let __sym2 = __pop_Variant10(__symbols); + let __sym3 = __pop_Variant11(__symbols); + let __sym2 = __pop_Variant11(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym4.2.clone(); let __nt = super::__action4::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (5, 16) } pub(crate) fn __reduce38< @@ -2499,14 +2544,14 @@ mod __parse__AIR { // Instr = "(", par, Instr, Instr, ")" => ActionFn(5); assert!(__symbols.len() >= 5); let __sym4 = __pop_Variant0(__symbols); - let __sym3 = __pop_Variant10(__symbols); - let __sym2 = __pop_Variant10(__symbols); + let __sym3 = __pop_Variant11(__symbols); + let __sym2 = __pop_Variant11(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym4.2.clone(); let __nt = super::__action5::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (5, 16) } pub(crate) fn __reduce39< @@ -2530,7 +2575,7 @@ mod __parse__AIR { let __start = __sym0.0.clone(); let __end = __sym2.2.clone(); let __nt = super::__action6::<>(input, errors, validator, __sym0, __sym1, __sym2); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (3, 16) } pub(crate) fn __reduce40< @@ -2546,19 +2591,18 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", fold, FoldScalarIterable, Scalar, Instr, ")" => ActionFn(75); - assert!(__symbols.len() >= 6); - let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant10(__symbols); - let __sym3 = __pop_Variant3(__symbols); - let __sym2 = __pop_Variant17(__symbols); + // Instr = "(", new, ScriptVariable, Instr, ")" => ActionFn(77); + assert!(__symbols.len() >= 5); + let __sym4 = __pop_Variant0(__symbols); + let __sym3 = __pop_Variant11(__symbols); + let __sym2 = __pop_Variant13(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym5.2.clone(); - let __nt = super::__action75::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (6, 16) + let __end = __sym4.2.clone(); + let __nt = super::__action77::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (5, 16) } pub(crate) fn __reduce41< 'err, @@ -2573,18 +2617,18 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", fold, Stream, Scalar, Instr, ")" => ActionFn(76); + // Instr = "(", fold, FoldScalarIterable, Scalar, Instr, ")" => ActionFn(78); assert!(__symbols.len() >= 6); let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant10(__symbols); - let __sym3 = __pop_Variant3(__symbols); - let __sym2 = __pop_Variant3(__symbols); + let __sym4 = __pop_Variant11(__symbols); + let __sym3 = __pop_Variant5(__symbols); + let __sym2 = __pop_Variant18(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym5.2.clone(); - let __nt = super::__action76::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + let __nt = super::__action78::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (6, 16) } pub(crate) fn __reduce42< @@ -2600,17 +2644,19 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", next, Scalar, ")" => ActionFn(77); - assert!(__symbols.len() >= 4); - let __sym3 = __pop_Variant0(__symbols); - let __sym2 = __pop_Variant3(__symbols); + // Instr = "(", fold, Stream, Scalar, Instr, ")" => ActionFn(79); + assert!(__symbols.len() >= 6); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant11(__symbols); + let __sym3 = __pop_Variant5(__symbols); + let __sym2 = __pop_Variant5(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym3.2.clone(); - let __nt = super::__action77::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (4, 16) + let __end = __sym5.2.clone(); + let __nt = super::__action79::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (6, 16) } pub(crate) fn __reduce43< 'err, @@ -2625,18 +2671,17 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", xor, Instr, Instr, ")" => ActionFn(10); - assert!(__symbols.len() >= 5); - let __sym4 = __pop_Variant0(__symbols); - let __sym3 = __pop_Variant10(__symbols); - let __sym2 = __pop_Variant10(__symbols); + // Instr = "(", next, Scalar, ")" => ActionFn(80); + assert!(__symbols.len() >= 4); + let __sym3 = __pop_Variant0(__symbols); + let __sym2 = __pop_Variant5(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym4.2.clone(); - let __nt = super::__action10::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (5, 16) + let __end = __sym3.2.clone(); + let __nt = super::__action80::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (4, 16) } pub(crate) fn __reduce44< 'err, @@ -2651,19 +2696,18 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", match_, Value, Value, Instr, ")" => ActionFn(78); - assert!(__symbols.len() >= 6); - let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant10(__symbols); - let __sym3 = __pop_Variant7(__symbols); - let __sym2 = __pop_Variant7(__symbols); + // Instr = "(", xor, Instr, Instr, ")" => ActionFn(11); + assert!(__symbols.len() >= 5); + let __sym4 = __pop_Variant0(__symbols); + let __sym3 = __pop_Variant11(__symbols); + let __sym2 = __pop_Variant11(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym5.2.clone(); - let __nt = super::__action78::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (6, 16) + let __end = __sym4.2.clone(); + let __nt = super::__action11::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (5, 16) } pub(crate) fn __reduce45< 'err, @@ -2678,18 +2722,18 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = "(", mismatch, Value, Value, Instr, ")" => ActionFn(79); + // Instr = "(", match_, Value, Value, Instr, ")" => ActionFn(81); assert!(__symbols.len() >= 6); let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant10(__symbols); - let __sym3 = __pop_Variant7(__symbols); - let __sym2 = __pop_Variant7(__symbols); + let __sym4 = __pop_Variant11(__symbols); + let __sym3 = __pop_Variant8(__symbols); + let __sym2 = __pop_Variant8(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym5.2.clone(); - let __nt = super::__action79::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + let __nt = super::__action81::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); (6, 16) } pub(crate) fn __reduce46< @@ -2705,13 +2749,19 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Instr = error => ActionFn(13); - let __sym0 = __pop_Variant6(__symbols); + // Instr = "(", mismatch, Value, Value, Instr, ")" => ActionFn(82); + assert!(__symbols.len() >= 6); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant11(__symbols); + let __sym3 = __pop_Variant8(__symbols); + let __sym2 = __pop_Variant8(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action13::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (1, 16) + let __end = __sym5.2.clone(); + let __nt = super::__action82::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (6, 16) } pub(crate) fn __reduce47< 'err, @@ -2726,13 +2776,13 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // PeerId = CallInstrValue => ActionFn(26); - let __sym0 = __pop_Variant14(__symbols); + // Instr = error => ActionFn(14); + let __sym0 = __pop_Variant7(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action26::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); - (1, 17) + let __nt = super::__action14::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant11(__nt), __end)); + (1, 16) } pub(crate) fn __reduce48< 'err, @@ -2747,13 +2797,13 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // PeerPart = PeerId => ActionFn(17); - let __sym0 = __pop_Variant14(__symbols); + // PeerId = CallInstrValue => ActionFn(27); + let __sym0 = __pop_Variant15(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action17::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant18(__nt), __end)); - (1, 18) + let __nt = super::__action27::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); + (1, 17) } pub(crate) fn __reduce49< 'err, @@ -2768,17 +2818,13 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // PeerPart = "(", PeerId, ServiceId, ")" => ActionFn(18); - assert!(__symbols.len() >= 4); - let __sym3 = __pop_Variant0(__symbols); - let __sym2 = __pop_Variant14(__symbols); - let __sym1 = __pop_Variant14(__symbols); - let __sym0 = __pop_Variant0(__symbols); + // PeerPart = PeerId => ActionFn(18); + let __sym0 = __pop_Variant15(__symbols); let __start = __sym0.0.clone(); - let __end = __sym3.2.clone(); - let __nt = super::__action18::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); - __symbols.push((__start, __Symbol::Variant18(__nt), __end)); - (4, 18) + let __end = __sym0.2.clone(); + let __nt = super::__action18::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant19(__nt), __end)); + (1, 18) } pub(crate) fn __reduce50< 'err, @@ -2793,13 +2839,17 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ScriptVariable = Scalar => ActionFn(21); - let __sym0 = __pop_Variant3(__symbols); + // PeerPart = "(", PeerId, ServiceId, ")" => ActionFn(19); + assert!(__symbols.len() >= 4); + let __sym3 = __pop_Variant0(__symbols); + let __sym2 = __pop_Variant15(__symbols); + let __sym1 = __pop_Variant15(__symbols); + let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action21::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant12(__nt), __end)); - (1, 19) + let __end = __sym3.2.clone(); + let __nt = super::__action19::<>(input, errors, validator, __sym0, __sym1, __sym2, __sym3); + __symbols.push((__start, __Symbol::Variant19(__nt), __end)); + (4, 18) } pub(crate) fn __reduce51< 'err, @@ -2814,12 +2864,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ScriptVariable = Stream => ActionFn(22); - let __sym0 = __pop_Variant3(__symbols); + // ScriptVariable = Scalar => ActionFn(22); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action22::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant12(__nt), __end)); + __symbols.push((__start, __Symbol::Variant13(__nt), __end)); (1, 19) } pub(crate) fn __reduce52< @@ -2835,13 +2885,13 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // ServiceId = CallInstrValue => ActionFn(27); - let __sym0 = __pop_Variant14(__symbols); + // ScriptVariable = Stream => ActionFn(23); + let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action27::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant14(__nt), __end)); - (1, 20) + let __nt = super::__action23::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant13(__nt), __end)); + (1, 19) } pub(crate) fn __reduce53< 'err, @@ -2856,13 +2906,13 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = InitPeerId => ActionFn(35); - let __sym0 = __pop_Variant0(__symbols); + // ServiceId = CallInstrValue => ActionFn(28); + let __sym0 = __pop_Variant15(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action35::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); - (1, 21) + let __nt = super::__action28::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant15(__nt), __end)); + (1, 20) } pub(crate) fn __reduce54< 'err, @@ -2877,12 +2927,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = LastError => ActionFn(36); - let __sym0 = __pop_Variant2(__symbols); + // Value = InitPeerId => ActionFn(36); + let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action36::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce55< @@ -2898,12 +2948,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = Literal => ActionFn(37); - let __sym0 = __pop_Variant3(__symbols); + // Value = LastError => ActionFn(37); + let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action37::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce56< @@ -2919,12 +2969,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = Number => ActionFn(38); - let __sym0 = __pop_Variant4(__symbols); + // Value = Literal => ActionFn(38); + let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action38::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce57< @@ -2940,12 +2990,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = Boolean => ActionFn(39); - let __sym0 = __pop_Variant1(__symbols); + // Value = Number => ActionFn(39); + let __sym0 = __pop_Variant4(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action39::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce58< @@ -2961,12 +3011,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = EmptyArray => ActionFn(40); - let __sym0 = __pop_Variant0(__symbols); + // Value = Boolean => ActionFn(40); + let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action40::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce59< @@ -2982,12 +3032,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = Scalar => ActionFn(41); - let __sym0 = __pop_Variant3(__symbols); + // Value = EmptyArray => ActionFn(41); + let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action41::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce60< @@ -3003,12 +3053,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = ScalarWithLambda => ActionFn(42); + // Value = Scalar => ActionFn(42); let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action42::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce61< @@ -3024,12 +3074,12 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = Stream => ActionFn(43); - let __sym0 = __pop_Variant3(__symbols); + // Value = ScalarWithLambda => ActionFn(43); + let __sym0 = __pop_Variant6(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action43::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } pub(crate) fn __reduce62< @@ -3045,12 +3095,33 @@ mod __parse__AIR { _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, ) -> (usize, usize) { - // Value = StreamWithLambda => ActionFn(44); + // Value = Stream => ActionFn(44); let __sym0 = __pop_Variant5(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); let __nt = super::__action44::<>(input, errors, validator, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (1, 21) + } + pub(crate) fn __reduce63< + 'err, + 'input, + 'v, + >( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __lookahead_start: Option<&usize>, + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>, + _: core::marker::PhantomData<(&'err (), &'input (), &'v ())>, + ) -> (usize, usize) + { + // Value = StreamWithLambda => ActionFn(45); + let __sym0 = __pop_Variant6(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action45::<>(input, errors, validator, __sym0); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); (1, 21) } } @@ -3116,10 +3187,11 @@ fn __action2< } }; - let output = output.map(CallOutputValue::Variable).unwrap_or(CallOutputValue::None); let args = Rc::new(args); - let call = Call { triplet, args, output}; - let span = Span { left, right }; + let output = output.map(CallOutputValue::Variable).unwrap_or(CallOutputValue::None); + let call = Call::new(triplet, args, output); + let span = Span::new(left, right); + validator.met_call(&call, span); Box::new(Instruction::Call(call)) @@ -3146,7 +3218,8 @@ fn __action3< { { let apply = Ap::new(arg, result); - let span = Span { left, right }; + + let span = Span::new(left, right); validator.met_ap(&apply, span); Box::new(Instruction::Ap(apply)) @@ -3169,7 +3242,7 @@ fn __action4< (_, _, _): (usize, Token<'input>, usize), ) -> Box> { - Box::new(Instruction::Seq(Seq(l, r))) + Box::new(Instruction::Seq(Seq::new(l, r))) } #[allow(unused_variables)] @@ -3188,7 +3261,7 @@ fn __action5< (_, _, _): (usize, Token<'input>, usize), ) -> Box> { - Box::new(Instruction::Par(Par(l, r))) + Box::new(Instruction::Par(Par::new(l, r))) } #[allow(unused_variables)] @@ -3220,21 +3293,19 @@ fn __action7< (_, left, _): (usize, usize, usize), (_, _, _): (usize, Token<'input>, usize), (_, _, _): (usize, Token<'input>, usize), - (_, iterable, _): (usize, ScalarWithLambda<'input>, usize), - (_, iterator_name, _): (usize, &'input str, usize), - (_, i, _): (usize, Box>, usize), + (_, variable, _): (usize, Variable<'input>, usize), + (_, instruction, _): (usize, Box>, usize), (_, _, _): (usize, Token<'input>, usize), (_, right, _): (usize, usize, usize), ) -> Box> { { - let iterator = Scalar { name: iterator_name }; - let instruction = Rc::new(*i); - let fold = FoldScalar { iterable, iterator, instruction }; - let span = Span { left, right }; - validator.met_fold_scalar(&fold, span); + let span = Span::new(left, right); + let new = New::new(variable, instruction, span); - Box::new(Instruction::FoldScalar(fold)) + validator.met_new(&new, span); + + Box::new(Instruction::New(new)) } } @@ -3250,23 +3321,21 @@ fn __action8< (_, left, _): (usize, usize, usize), (_, _, _): (usize, Token<'input>, usize), (_, _, _): (usize, Token<'input>, usize), - (_, stream_name, _): (usize, &'input str, usize), - (_, iterator_name, _): (usize, &'input str, usize), + (_, iterable, _): (usize, ScalarWithLambda<'input>, usize), + (_, iterator, _): (usize, (&'input str, usize), usize), (_, i, _): (usize, Box>, usize), (_, _, _): (usize, Token<'input>, usize), (_, right, _): (usize, usize, usize), ) -> Box> { { - let iterable = Stream { name: stream_name }; - let iterator = Scalar { name: iterator_name }; - let instruction = Rc::new(*i); - let fold = FoldStream { iterable, iterator, instruction }; + let iterator = Scalar::new(iterator.0, iterator.1); + let span = Span::new(left, right); + let fold = FoldScalar::new(iterable, iterator, *i, span); - let span = Span { left, right }; - validator.meet_fold_stream(&fold, span); + validator.met_fold_scalar(&fold, span); - Box::new(Instruction::FoldStream(fold)) + Box::new(Instruction::FoldScalar(fold)) } } @@ -3282,15 +3351,46 @@ fn __action9< (_, left, _): (usize, usize, usize), (_, _, _): (usize, Token<'input>, usize), (_, _, _): (usize, Token<'input>, usize), - (_, iterator_name, _): (usize, &'input str, usize), + (_, stream, _): (usize, (&'input str, usize), usize), + (_, iterator, _): (usize, (&'input str, usize), usize), + (_, i, _): (usize, Box>, usize), (_, _, _): (usize, Token<'input>, usize), (_, right, _): (usize, usize, usize), ) -> Box> { { - let iterator = Scalar { name: iterator_name }; - let next = Next { iterator }; - let span = Span { left, right }; + let iterable = Stream::new(stream.0, stream.1); + let iterator = Scalar::new(iterator.0, iterator.1); + let span = Span::new(left, right); + let fold = FoldStream::new(iterable, iterator, *i, span); + + validator.meet_fold_stream(&fold, span); + + Box::new(Instruction::FoldStream(fold)) + } +} + +#[allow(unused_variables)] +fn __action10< + 'err, + 'input, + 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, left, _): (usize, usize, usize), + (_, _, _): (usize, Token<'input>, usize), + (_, _, _): (usize, Token<'input>, usize), + (_, iterator, _): (usize, (&'input str, usize), usize), + (_, _, _): (usize, Token<'input>, usize), + (_, right, _): (usize, usize, usize), +) -> Box> +{ + { + let iterator = Scalar::new(iterator.0, iterator.1); + let next = Next::new(iterator); + let span = Span::new(left, right); validator.met_next(&next, span); Box::new(Instruction::Next(next)) @@ -3298,7 +3398,7 @@ fn __action9< } #[allow(unused_variables)] -fn __action10< +fn __action11< 'err, 'input, 'v, @@ -3316,34 +3416,6 @@ fn __action10< Box::new(Instruction::Xor(Xor(l, r))) } -#[allow(unused_variables)] -fn __action11< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - (_, left, _): (usize, usize, usize), - (_, _, _): (usize, Token<'input>, usize), - (_, _, _): (usize, Token<'input>, usize), - (_, l, _): (usize, Value<'input>, usize), - (_, r, _): (usize, Value<'input>, usize), - (_, i, _): (usize, Box>, usize), - (_, _, _): (usize, Token<'input>, usize), - (_, right, _): (usize, usize, usize), -) -> Box> -{ - { - let match_ = Match { left_value: l, right_value: r, instruction: i}; - let span = Span { left, right }; - validator.met_match(&match_, span); - - Box::new(Instruction::Match(match_)) - } -} - #[allow(unused_variables)] fn __action12< 'err, @@ -3364,8 +3436,36 @@ fn __action12< ) -> Box> { { - let mismatch = MisMatch { left_value: l, right_value: r, instruction: i}; - let span = Span { left, right }; + let match_ = Match::new(l, r, i); + let span = Span::new(left, right); + validator.met_match(&match_, span); + + Box::new(Instruction::Match(match_)) + } +} + +#[allow(unused_variables)] +fn __action13< + 'err, + 'input, + 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, left, _): (usize, usize, usize), + (_, _, _): (usize, Token<'input>, usize), + (_, _, _): (usize, Token<'input>, usize), + (_, l, _): (usize, Value<'input>, usize), + (_, r, _): (usize, Value<'input>, usize), + (_, i, _): (usize, Box>, usize), + (_, _, _): (usize, Token<'input>, usize), + (_, right, _): (usize, usize, usize), +) -> Box> +{ + { + let mismatch = MisMatch::new(l, r, i); + let span = Span::new(left, right); validator.met_mismatch(&mismatch, span); Box::new(Instruction::MisMatch(mismatch)) @@ -3373,7 +3473,7 @@ fn __action12< } #[allow(unused_variables)] -fn __action13< +fn __action14< 'err, 'input, 'v, @@ -3388,7 +3488,7 @@ fn __action13< } #[allow(unused_variables)] -fn __action14< +fn __action15< 'err, 'input, 'v, @@ -3405,7 +3505,7 @@ fn __action14< } #[allow(unused_variables)] -fn __action15< +fn __action16< 'err, 'input, 'v, @@ -3420,7 +3520,7 @@ fn __action15< } #[allow(unused_variables)] -fn __action16< +fn __action17< 'err, 'input, 'v, @@ -3438,7 +3538,7 @@ fn __action16< } #[allow(unused_variables)] -fn __action17< +fn __action18< 'err, 'input, 'v, @@ -3453,7 +3553,7 @@ fn __action17< } #[allow(unused_variables)] -fn __action18< +fn __action19< 'err, 'input, 'v, @@ -3470,21 +3570,6 @@ fn __action18< PeerPart::PeerPkWithServiceId(pid, sid) } -#[allow(unused_variables)] -fn __action19< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - (_, __0, _): (usize, Variable<'input>, usize), -) -> Variable<'input> -{ - __0 -} - #[allow(unused_variables)] fn __action20< 'err, @@ -3509,10 +3594,10 @@ fn __action21< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, &'input str, usize), + (_, __0, _): (usize, Variable<'input>, usize), ) -> Variable<'input> { - Variable::scalar(scalar) + __0 } #[allow(unused_variables)] @@ -3524,10 +3609,10 @@ fn __action22< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, stream, _): (usize, &'input str, usize), + (_, scalar, _): (usize, (&'input str, usize), usize), ) -> Variable<'input> { - Variable::stream(stream) + Variable::scalar(scalar.0, scalar.1) } #[allow(unused_variables)] @@ -3539,10 +3624,10 @@ fn __action23< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, &'input str, usize), -) -> ScalarWithLambda<'input> + (_, stream, _): (usize, (&'input str, usize), usize), +) -> Variable<'input> { - ScalarWithLambda::new(scalar, None) + Variable::stream(stream.0, stream.1) } #[allow(unused_variables)] @@ -3554,10 +3639,10 @@ fn __action24< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, scalar, _): (usize, (&'input str, usize), usize), ) -> ScalarWithLambda<'input> { - ScalarWithLambda::new(scalar.0, Some(scalar.1)) + ScalarWithLambda::new(scalar.0, None, scalar.1) } #[allow(unused_variables)] @@ -3569,10 +3654,10 @@ fn __action25< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, __0, _): (usize, CallInstrValue<'input>, usize), -) -> CallInstrValue<'input> + (_, scalar, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), +) -> ScalarWithLambda<'input> { - __0 + ScalarWithLambda::new(scalar.0, Some(scalar.1), scalar.2) } #[allow(unused_variables)] @@ -3610,6 +3695,21 @@ fn __action28< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, __0, _): (usize, CallInstrValue<'input>, usize), +) -> CallInstrValue<'input> +{ + __0 +} + +#[allow(unused_variables)] +fn __action29< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -3621,7 +3721,7 @@ fn __action28< } #[allow(unused_variables)] -fn __action29< +fn __action30< 'err, 'input, 'v, @@ -3635,21 +3735,6 @@ fn __action29< CallInstrValue::Literal(l) } -#[allow(unused_variables)] -fn __action30< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, &'input str, usize), -) -> CallInstrValue<'input> -{ - CallInstrValue::Variable(VariableWithLambda::scalar(scalar)) -} - #[allow(unused_variables)] fn __action31< 'err, @@ -3659,10 +3744,10 @@ fn __action31< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, scalar, _): (usize, (&'input str, usize), usize), ) -> CallInstrValue<'input> { - CallInstrValue::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1)) + CallInstrValue::Variable(VariableWithLambda::scalar(scalar.0, scalar.1)) } #[allow(unused_variables)] @@ -3674,10 +3759,10 @@ fn __action32< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, stream, _): (usize, &'input str, usize), + (_, scalar, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), ) -> CallInstrValue<'input> { - CallInstrValue::Variable(VariableWithLambda::stream(stream)) + CallInstrValue::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1, scalar.2)) } #[allow(unused_variables)] @@ -3689,10 +3774,10 @@ fn __action33< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, stream, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, stream, _): (usize, (&'input str, usize), usize), ) -> CallInstrValue<'input> { - CallInstrValue::Variable(VariableWithLambda::stream_wl(stream.0, stream.1)) + CallInstrValue::Variable(VariableWithLambda::stream(stream.0, stream.1)) } #[allow(unused_variables)] @@ -3700,6 +3785,21 @@ fn __action34< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, stream, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), +) -> CallInstrValue<'input> +{ + CallInstrValue::Variable(VariableWithLambda::stream_wl(stream.0, stream.1, stream.2)) +} + +#[allow(unused_variables)] +fn __action35< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -3711,7 +3811,7 @@ fn __action34< } #[allow(unused_variables)] -fn __action35< +fn __action36< 'err, 'input, 'v, @@ -3726,7 +3826,7 @@ fn __action35< } #[allow(unused_variables)] -fn __action36< +fn __action37< 'err, 'input, 'v, @@ -3741,7 +3841,7 @@ fn __action36< } #[allow(unused_variables)] -fn __action37< +fn __action38< 'err, 'input, 'v, @@ -3756,7 +3856,7 @@ fn __action37< } #[allow(unused_variables)] -fn __action38< +fn __action39< 'err, 'input, 'v, @@ -3771,7 +3871,7 @@ fn __action38< } #[allow(unused_variables)] -fn __action39< +fn __action40< 'err, 'input, 'v, @@ -3786,7 +3886,7 @@ fn __action39< } #[allow(unused_variables)] -fn __action40< +fn __action41< 'err, 'input, 'v, @@ -3800,21 +3900,6 @@ fn __action40< Value::EmptyArray } -#[allow(unused_variables)] -fn __action41< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - (_, scalar_name, _): (usize, &'input str, usize), -) -> Value<'input> -{ - Value::Variable(VariableWithLambda::scalar(scalar_name)) -} - #[allow(unused_variables)] fn __action42< 'err, @@ -3824,10 +3909,10 @@ fn __action42< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, scalar, _): (usize, (&'input str, usize), usize), ) -> Value<'input> { - Value::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1)) + Value::Variable(VariableWithLambda::scalar(scalar.0, scalar.1)) } #[allow(unused_variables)] @@ -3839,10 +3924,10 @@ fn __action43< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, stream_name, _): (usize, &'input str, usize), + (_, scalar, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), ) -> Value<'input> { - Value::Variable(VariableWithLambda::stream(stream_name)) + Value::Variable(VariableWithLambda::scalar_wl(scalar.0, scalar.1, scalar.2)) } #[allow(unused_variables)] @@ -3854,10 +3939,10 @@ fn __action44< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, stream, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, stream, _): (usize, (&'input str, usize), usize), ) -> Value<'input> { - Value::Variable(VariableWithLambda::stream_wl(stream.0, stream.1)) + Value::Variable(VariableWithLambda::stream(stream.0, stream.1)) } #[allow(unused_variables)] @@ -3865,6 +3950,21 @@ fn __action45< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, stream, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), +) -> Value<'input> +{ + Value::Variable(VariableWithLambda::stream_wl(stream.0, stream.1, stream.2)) +} + +#[allow(unused_variables)] +fn __action46< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -3876,7 +3976,7 @@ fn __action45< } #[allow(unused_variables)] -fn __action46< +fn __action47< 'err, 'input, 'v, @@ -3891,7 +3991,7 @@ fn __action46< } #[allow(unused_variables)] -fn __action47< +fn __action48< 'err, 'input, 'v, @@ -3906,7 +4006,7 @@ fn __action47< } #[allow(unused_variables)] -fn __action48< +fn __action49< 'err, 'input, 'v, @@ -3921,7 +4021,7 @@ fn __action48< } #[allow(unused_variables)] -fn __action49< +fn __action50< 'err, 'input, 'v, @@ -3936,7 +4036,7 @@ fn __action49< } #[allow(unused_variables)] -fn __action50< +fn __action51< 'err, 'input, 'v, @@ -3950,21 +4050,6 @@ fn __action50< ApArgument::EmptyArray } -#[allow(unused_variables)] -fn __action51< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, &'input str, usize), -) -> ApArgument<'input> -{ - ApArgument::Scalar(ScalarWithLambda { name: scalar, lambda: None }) -} - #[allow(unused_variables)] fn __action52< 'err, @@ -3974,10 +4059,10 @@ fn __action52< input: &'input str, errors: &'err mut Vec, ParserError>>, validator: &'v mut VariableValidator<'input>, - (_, scalar, _): (usize, (&'input str, LambdaAST<'input>), usize), + (_, scalar, _): (usize, (&'input str, usize), usize), ) -> ApArgument<'input> { - ApArgument::Scalar(ScalarWithLambda { name: scalar.0, lambda: Some(scalar.1) }) + ApArgument::Scalar(ScalarWithLambda::new(scalar.0, None, scalar.1)) } #[allow(unused_variables)] @@ -3985,6 +4070,21 @@ fn __action53< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + (_, scalar, _): (usize, (&'input str, LambdaAST<'input>, usize), usize), +) -> ApArgument<'input> +{ + ApArgument::Scalar(ScalarWithLambda::new(scalar.0, Some(scalar.1), scalar.2)) +} + +#[allow(unused_variables)] +fn __action54< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -3997,7 +4097,7 @@ fn __action53< } #[allow(unused_variables)] -fn __action54< +fn __action55< 'err, 'input, 'v, @@ -4012,7 +4112,7 @@ fn __action54< } #[allow(unused_variables)] -fn __action55< +fn __action56< 'err, 'input, 'v, @@ -4027,7 +4127,7 @@ fn __action55< } #[allow(unused_variables)] -fn __action56< +fn __action57< 'err, 'input, 'v, @@ -4043,7 +4143,7 @@ fn __action56< } #[allow(unused_variables)] -fn __action57< +fn __action58< 'err, 'input, 'v, @@ -4058,7 +4158,7 @@ fn __action57< } #[allow(unused_variables)] -fn __action58< +fn __action59< 'err, 'input, 'v, @@ -4074,7 +4174,7 @@ fn __action58< } #[allow(unused_variables)] -fn __action59< +fn __action60< 'err, 'input, 'v, @@ -4090,7 +4190,7 @@ fn __action59< } #[allow(unused_variables)] -fn __action60< +fn __action61< 'err, 'input, 'v, @@ -4105,7 +4205,7 @@ fn __action60< } #[allow(unused_variables)] -fn __action61< +fn __action62< 'err, 'input, 'v, @@ -4121,7 +4221,7 @@ fn __action61< } #[allow(unused_variables)] -fn __action62< +fn __action63< 'err, 'input, 'v, @@ -4134,48 +4234,17 @@ fn __action62< { let __start0 = __0.0.clone(); let __end0 = __0.2.clone(); - let __temp0 = __action55( + let __temp0 = __action56( input, errors, validator, __0, ); let __temp0 = (__start0, __temp0, __end0); - __action60( - input, - errors, - validator, - __temp0, - ) -} - -#[allow(unused_variables)] -fn __action63< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - __0: (usize, alloc::vec::Vec>, usize), - __1: (usize, Value<'input>, usize), -) -> alloc::vec::Vec> -{ - let __start0 = __1.0.clone(); - let __end0 = __1.2.clone(); - let __temp0 = __action55( - input, - errors, - validator, - __1, - ); - let __temp0 = (__start0, __temp0, __end0); __action61( input, errors, validator, - __0, __temp0, ) } @@ -4185,6 +4254,37 @@ fn __action64< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, alloc::vec::Vec>, usize), + __1: (usize, Value<'input>, usize), +) -> alloc::vec::Vec> +{ + let __start0 = __1.0.clone(); + let __end0 = __1.2.clone(); + let __temp0 = __action56( + input, + errors, + validator, + __1, + ); + let __temp0 = (__start0, __temp0, __end0); + __action62( + input, + errors, + validator, + __0, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action65< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -4195,7 +4295,7 @@ fn __action64< { let __start0 = __0.2.clone(); let __end0 = __1.0.clone(); - let __temp0 = __action53( + let __temp0 = __action54( input, errors, validator, @@ -4203,7 +4303,7 @@ fn __action64< &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action14( + __action15( input, errors, validator, @@ -4214,7 +4314,7 @@ fn __action64< } #[allow(unused_variables)] -fn __action65< +fn __action66< 'err, 'input, 'v, @@ -4229,14 +4329,14 @@ fn __action65< { let __start0 = __1.0.clone(); let __end0 = __1.2.clone(); - let __temp0 = __action54( + let __temp0 = __action55( input, errors, validator, __1, ); let __temp0 = (__start0, __temp0, __end0); - __action14( + __action15( input, errors, validator, @@ -4247,7 +4347,7 @@ fn __action65< } #[allow(unused_variables)] -fn __action66< +fn __action67< 'err, 'input, 'v, @@ -4267,7 +4367,7 @@ fn __action66< { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4292,7 +4392,7 @@ fn __action66< } #[allow(unused_variables)] -fn __action67< +fn __action68< 'err, 'input, 'v, @@ -4310,7 +4410,7 @@ fn __action67< { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4333,7 +4433,7 @@ fn __action67< } #[allow(unused_variables)] -fn __action68< +fn __action69< 'err, 'input, 'v, @@ -4343,16 +4443,15 @@ fn __action68< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, ScalarWithLambda<'input>, usize), - __3: (usize, &'input str, usize), - __4: (usize, Box>, usize), - __5: (usize, Token<'input>, usize), - __6: (usize, usize, usize), + __2: (usize, Variable<'input>, usize), + __3: (usize, Box>, usize), + __4: (usize, Token<'input>, usize), + __5: (usize, usize, usize), ) -> Box> { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4371,12 +4470,11 @@ fn __action68< __3, __4, __5, - __6, ) } #[allow(unused_variables)] -fn __action69< +fn __action70< 'err, 'input, 'v, @@ -4386,8 +4484,8 @@ fn __action69< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, &'input str, usize), - __3: (usize, &'input str, usize), + __2: (usize, ScalarWithLambda<'input>, usize), + __3: (usize, (&'input str, usize), usize), __4: (usize, Box>, usize), __5: (usize, Token<'input>, usize), __6: (usize, usize, usize), @@ -4395,7 +4493,7 @@ fn __action69< { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4418,45 +4516,6 @@ fn __action69< ) } -#[allow(unused_variables)] -fn __action70< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - __0: (usize, Token<'input>, usize), - __1: (usize, Token<'input>, usize), - __2: (usize, &'input str, usize), - __3: (usize, Token<'input>, usize), - __4: (usize, usize, usize), -) -> Box> -{ - let __start0 = __0.0.clone(); - let __end0 = __0.0.clone(); - let __temp0 = __action59( - input, - errors, - validator, - &__start0, - &__end0, - ); - let __temp0 = (__start0, __temp0, __end0); - __action9( - input, - errors, - validator, - __temp0, - __0, - __1, - __2, - __3, - __4, - ) -} - #[allow(unused_variables)] fn __action71< 'err, @@ -4468,8 +4527,8 @@ fn __action71< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, Value<'input>, usize), - __3: (usize, Value<'input>, usize), + __2: (usize, (&'input str, usize), usize), + __3: (usize, (&'input str, usize), usize), __4: (usize, Box>, usize), __5: (usize, Token<'input>, usize), __6: (usize, usize, usize), @@ -4477,7 +4536,7 @@ fn __action71< { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4485,7 +4544,7 @@ fn __action71< &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action11( + __action9( input, errors, validator, @@ -4505,6 +4564,45 @@ fn __action72< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, Token<'input>, usize), + __1: (usize, Token<'input>, usize), + __2: (usize, (&'input str, usize), usize), + __3: (usize, Token<'input>, usize), + __4: (usize, usize, usize), +) -> Box> +{ + let __start0 = __0.0.clone(); + let __end0 = __0.0.clone(); + let __temp0 = __action60( + input, + errors, + validator, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action10( + input, + errors, + validator, + __temp0, + __0, + __1, + __2, + __3, + __4, + ) +} + +#[allow(unused_variables)] +fn __action73< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -4520,7 +4618,7 @@ fn __action72< { let __start0 = __0.0.clone(); let __end0 = __0.0.clone(); - let __temp0 = __action59( + let __temp0 = __action60( input, errors, validator, @@ -4544,7 +4642,50 @@ fn __action72< } #[allow(unused_variables)] -fn __action73< +fn __action74< + 'err, + 'input, + 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, Token<'input>, usize), + __1: (usize, Token<'input>, usize), + __2: (usize, Value<'input>, usize), + __3: (usize, Value<'input>, usize), + __4: (usize, Box>, usize), + __5: (usize, Token<'input>, usize), + __6: (usize, usize, usize), +) -> Box> +{ + let __start0 = __0.0.clone(); + let __end0 = __0.0.clone(); + let __temp0 = __action60( + input, + errors, + validator, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action13( + input, + errors, + validator, + __temp0, + __0, + __1, + __2, + __3, + __4, + __5, + __6, + ) +} + +#[allow(unused_variables)] +fn __action75< 'err, 'input, 'v, @@ -4563,48 +4704,7 @@ fn __action73< { let __start0 = __6.2.clone(); let __end0 = __6.2.clone(); - let __temp0 = __action56( - input, - errors, - validator, - &__start0, - &__end0, - ); - let __temp0 = (__start0, __temp0, __end0); - __action66( - input, - errors, - validator, - __0, - __1, - __2, - __3, - __4, - __5, - __6, - __temp0, - ) -} - -#[allow(unused_variables)] -fn __action74< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - __0: (usize, Token<'input>, usize), - __1: (usize, Token<'input>, usize), - __2: (usize, ApArgument<'input>, usize), - __3: (usize, Variable<'input>, usize), - __4: (usize, Token<'input>, usize), -) -> Box> -{ - let __start0 = __4.2.clone(); - let __end0 = __4.2.clone(); - let __temp0 = __action56( + let __temp0 = __action57( input, errors, validator, @@ -4621,12 +4721,14 @@ fn __action74< __2, __3, __4, + __5, + __6, __temp0, ) } #[allow(unused_variables)] -fn __action75< +fn __action76< 'err, 'input, 'v, @@ -4636,15 +4738,14 @@ fn __action75< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, ScalarWithLambda<'input>, usize), - __3: (usize, &'input str, usize), - __4: (usize, Box>, usize), - __5: (usize, Token<'input>, usize), + __2: (usize, ApArgument<'input>, usize), + __3: (usize, Variable<'input>, usize), + __4: (usize, Token<'input>, usize), ) -> Box> { - let __start0 = __5.2.clone(); - let __end0 = __5.2.clone(); - let __temp0 = __action56( + let __start0 = __4.2.clone(); + let __end0 = __4.2.clone(); + let __temp0 = __action57( input, errors, validator, @@ -4661,13 +4762,12 @@ fn __action75< __2, __3, __4, - __5, __temp0, ) } #[allow(unused_variables)] -fn __action76< +fn __action77< 'err, 'input, 'v, @@ -4677,15 +4777,14 @@ fn __action76< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, &'input str, usize), - __3: (usize, &'input str, usize), - __4: (usize, Box>, usize), - __5: (usize, Token<'input>, usize), + __2: (usize, Variable<'input>, usize), + __3: (usize, Box>, usize), + __4: (usize, Token<'input>, usize), ) -> Box> { - let __start0 = __5.2.clone(); - let __end0 = __5.2.clone(); - let __temp0 = __action56( + let __start0 = __4.2.clone(); + let __end0 = __4.2.clone(); + let __temp0 = __action57( input, errors, validator, @@ -4702,44 +4801,6 @@ fn __action76< __2, __3, __4, - __5, - __temp0, - ) -} - -#[allow(unused_variables)] -fn __action77< - 'err, - 'input, - 'v, ->( - input: &'input str, - errors: &'err mut Vec, ParserError>>, - validator: &'v mut VariableValidator<'input>, - __0: (usize, Token<'input>, usize), - __1: (usize, Token<'input>, usize), - __2: (usize, &'input str, usize), - __3: (usize, Token<'input>, usize), -) -> Box> -{ - let __start0 = __3.2.clone(); - let __end0 = __3.2.clone(); - let __temp0 = __action56( - input, - errors, - validator, - &__start0, - &__end0, - ); - let __temp0 = (__start0, __temp0, __end0); - __action70( - input, - errors, - validator, - __0, - __1, - __2, - __3, __temp0, ) } @@ -4755,15 +4816,15 @@ fn __action78< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, Value<'input>, usize), - __3: (usize, Value<'input>, usize), + __2: (usize, ScalarWithLambda<'input>, usize), + __3: (usize, (&'input str, usize), usize), __4: (usize, Box>, usize), __5: (usize, Token<'input>, usize), ) -> Box> { let __start0 = __5.2.clone(); let __end0 = __5.2.clone(); - let __temp0 = __action56( + let __temp0 = __action57( input, errors, validator, @@ -4771,7 +4832,7 @@ fn __action78< &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action71( + __action70( input, errors, validator, @@ -4796,15 +4857,15 @@ fn __action79< validator: &'v mut VariableValidator<'input>, __0: (usize, Token<'input>, usize), __1: (usize, Token<'input>, usize), - __2: (usize, Value<'input>, usize), - __3: (usize, Value<'input>, usize), + __2: (usize, (&'input str, usize), usize), + __3: (usize, (&'input str, usize), usize), __4: (usize, Box>, usize), __5: (usize, Token<'input>, usize), ) -> Box> { let __start0 = __5.2.clone(); let __end0 = __5.2.clone(); - let __temp0 = __action56( + let __temp0 = __action57( input, errors, validator, @@ -4812,7 +4873,7 @@ fn __action79< &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action72( + __action71( input, errors, validator, @@ -4831,6 +4892,125 @@ fn __action80< 'err, 'input, 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, Token<'input>, usize), + __1: (usize, Token<'input>, usize), + __2: (usize, (&'input str, usize), usize), + __3: (usize, Token<'input>, usize), +) -> Box> +{ + let __start0 = __3.2.clone(); + let __end0 = __3.2.clone(); + let __temp0 = __action57( + input, + errors, + validator, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action72( + input, + errors, + validator, + __0, + __1, + __2, + __3, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action81< + 'err, + 'input, + 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, Token<'input>, usize), + __1: (usize, Token<'input>, usize), + __2: (usize, Value<'input>, usize), + __3: (usize, Value<'input>, usize), + __4: (usize, Box>, usize), + __5: (usize, Token<'input>, usize), +) -> Box> +{ + let __start0 = __5.2.clone(); + let __end0 = __5.2.clone(); + let __temp0 = __action57( + input, + errors, + validator, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action73( + input, + errors, + validator, + __0, + __1, + __2, + __3, + __4, + __5, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action82< + 'err, + 'input, + 'v, +>( + input: &'input str, + errors: &'err mut Vec, ParserError>>, + validator: &'v mut VariableValidator<'input>, + __0: (usize, Token<'input>, usize), + __1: (usize, Token<'input>, usize), + __2: (usize, Value<'input>, usize), + __3: (usize, Value<'input>, usize), + __4: (usize, Box>, usize), + __5: (usize, Token<'input>, usize), +) -> Box> +{ + let __start0 = __5.2.clone(); + let __end0 = __5.2.clone(); + let __temp0 = __action57( + input, + errors, + validator, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action74( + input, + errors, + validator, + __0, + __1, + __2, + __3, + __4, + __5, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action83< + 'err, + 'input, + 'v, >( input: &'input str, errors: &'err mut Vec, ParserError>>, @@ -4846,14 +5026,14 @@ fn __action80< { let __start0 = __5.0.clone(); let __end0 = __5.2.clone(); - let __temp0 = __action57( + let __temp0 = __action58( input, errors, validator, __5, ); let __temp0 = (__start0, __temp0, __end0); - __action73( + __action75( input, errors, validator, @@ -4868,7 +5048,7 @@ fn __action80< } #[allow(unused_variables)] -fn __action81< +fn __action84< 'err, 'input, 'v, @@ -4886,7 +5066,7 @@ fn __action81< { let __start0 = __4.2.clone(); let __end0 = __5.0.clone(); - let __temp0 = __action58( + let __temp0 = __action59( input, errors, validator, @@ -4894,7 +5074,7 @@ fn __action81< &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action73( + __action75( input, errors, validator, diff --git a/crates/air-lib/air-parser/src/parser/air_parser.rs b/crates/air-lib/air-parser/src/parser/air_parser.rs index 5dff2008..b381bbe4 100644 --- a/crates/air-lib/air-parser/src/parser/air_parser.rs +++ b/crates/air-lib/air-parser/src/parser/air_parser.rs @@ -136,6 +136,9 @@ fn parser_error_to_label(file_id: usize, error: ParserError) -> Label { InvalidCallTriplet(start, end) => { Label::primary(file_id, start..end).with_message(error.to_string()) } + IteratorRestrictionNotAllowed(start, end, _) => { + Label::primary(file_id, start..end).with_message(error.to_string()) + } } } diff --git a/crates/air-lib/air-parser/src/parser/errors.rs b/crates/air-lib/air-parser/src/parser/errors.rs index 3b4bd407..09bf7a47 100644 --- a/crates/air-lib/air-parser/src/parser/errors.rs +++ b/crates/air-lib/air-parser/src/parser/errors.rs @@ -34,6 +34,9 @@ pub enum ParserError { /// Semantic errors in a call instructions. #[error("call should have service id specified by peer part or function part")] InvalidCallTriplet(usize, usize), + + #[error("new can't be applied to a '{2}' because it's an iterator")] + IteratorRestrictionNotAllowed(usize, usize, String), } impl From for ParserError { diff --git a/crates/air-lib/air-parser/src/parser/lexer/air_lexer.rs b/crates/air-lib/air-parser/src/parser/lexer/air_lexer.rs index 12bfc7ee..d91bec4c 100644 --- a/crates/air-lib/air-parser/src/parser/lexer/air_lexer.rs +++ b/crates/air-lib/air-parser/src/parser/lexer/air_lexer.rs @@ -192,10 +192,11 @@ fn string_to_token(input: &str, start_pos: usize) -> LexerResult { AP_INSTR => Ok(Token::Ap), SEQ_INSTR => Ok(Token::Seq), PAR_INSTR => Ok(Token::Par), - NULL_INSTR => Ok(Token::Null), FOLD_INSTR => Ok(Token::Fold), XOR_INSTR => Ok(Token::Xor), + NEW_INSTR => Ok(Token::New), NEXT_INSTR => Ok(Token::Next), + NULL_INSTR => Ok(Token::Null), MATCH_INSTR => Ok(Token::Match), MISMATCH_INSTR => Ok(Token::MisMatch), @@ -237,10 +238,11 @@ const CALL_INSTR: &str = "call"; const AP_INSTR: &str = "ap"; const SEQ_INSTR: &str = "seq"; const PAR_INSTR: &str = "par"; -const NULL_INSTR: &str = "null"; const FOLD_INSTR: &str = "fold"; const XOR_INSTR: &str = "xor"; +const NEW_INSTR: &str = "new"; const NEXT_INSTR: &str = "next"; +const NULL_INSTR: &str = "null"; const MATCH_INSTR: &str = "match"; const MISMATCH_INSTR: &str = "mismatch"; diff --git a/crates/air-lib/air-parser/src/parser/lexer/call_variable_parser.rs b/crates/air-lib/air-parser/src/parser/lexer/call_variable_parser.rs index a9c1d6fd..18c13ed4 100644 --- a/crates/air-lib/air-parser/src/parser/lexer/call_variable_parser.rs +++ b/crates/air-lib/air-parser/src/parser/lexer/call_variable_parser.rs @@ -274,17 +274,31 @@ impl<'input> CallVariableParser<'input> { fn to_variable_token<'v>(&self, name: &'v str) -> Token<'v> { if self.state.is_first_stream_tag { - Token::Stream { name } + Token::Stream { + name, + position: self.start_pos, + } } else { - Token::Scalar { name } + Token::Scalar { + name, + position: self.start_pos, + } } } fn to_variable_token_with_lambda<'v>(&self, name: &'v str, lambda: LambdaAST<'v>) -> Token<'v> { if self.state.is_first_stream_tag { - Token::StreamWithLambda { name, lambda } + Token::StreamWithLambda { + name, + lambda, + position: self.start_pos, + } } else { - Token::ScalarWithLambda { name, lambda } + Token::ScalarWithLambda { + name, + lambda, + position: self.start_pos, + } } } diff --git a/crates/air-lib/air-parser/src/parser/lexer/tests.rs b/crates/air-lib/air-parser/src/parser/lexer/tests.rs index 8c5b79bd..8b8005f4 100644 --- a/crates/air-lib/air-parser/src/parser/lexer/tests.rs +++ b/crates/air-lib/air-parser/src/parser/lexer/tests.rs @@ -160,7 +160,14 @@ fn stream() { lexer_test( STREAM, - Single(Ok((0, Token::Stream { name: STREAM }, STREAM.len()))), + Single(Ok(( + 0, + Token::Stream { + name: STREAM, + position: 0, + }, + STREAM.len(), + ))), ); } @@ -284,6 +291,7 @@ fn lambda() { ValueAccessor::ArrayAccess { idx: 1 }, ]) }, + position: 0, }, LAMBDA.len(), ))), @@ -453,6 +461,7 @@ fn booleans() { 0, Token::Scalar { name: NON_BOOL_CONST, + position: 0, }, NON_BOOL_CONST.len(), ))), diff --git a/crates/air-lib/air-parser/src/parser/lexer/token.rs b/crates/air-lib/air-parser/src/parser/lexer/token.rs index 8c9f3473..3806a2c2 100644 --- a/crates/air-lib/air-parser/src/parser/lexer/token.rs +++ b/crates/air-lib/air-parser/src/parser/lexer/token.rs @@ -34,17 +34,21 @@ pub enum Token<'input> { StringLiteral(&'input str), Scalar { name: &'input str, + position: usize, }, ScalarWithLambda { name: &'input str, lambda: LambdaAST<'input>, + position: usize, }, Stream { name: &'input str, + position: usize, }, StreamWithLambda { name: &'input str, lambda: LambdaAST<'input>, + position: usize, }, Number(Number), Boolean(bool), @@ -56,10 +60,11 @@ pub enum Token<'input> { Ap, Seq, Par, - Null, Fold, Xor, + New, Next, + Null, Match, MisMatch, } diff --git a/crates/air-lib/air-parser/src/parser/mod.rs b/crates/air-lib/air-parser/src/parser/mod.rs index a02549d3..1453ed70 100644 --- a/crates/air-lib/air-parser/src/parser/mod.rs +++ b/crates/air-lib/air-parser/src/parser/mod.rs @@ -17,6 +17,7 @@ pub mod air_parser; mod air_utils; pub(crate) mod lexer; +mod span; // air is auto-generated, so exclude it from `cargo fmt -- --check` and `cargo clippy` #[rustfmt::skip] @@ -32,12 +33,7 @@ pub mod tests; pub use self::air_parser::parse; pub use air::AIRParser; pub use lexer::AIRLexer; +pub use span::Span; pub use validator::VariableValidator; use errors::ParserError; - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct Span { - pub left: usize, - pub right: usize, -} diff --git a/crates/air-lib/air-parser/src/parser/span.rs b/crates/air-lib/air-parser/src/parser/span.rs new file mode 100644 index 00000000..2b61ebd8 --- /dev/null +++ b/crates/air-lib/air-parser/src/parser/span.rs @@ -0,0 +1,34 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use serde::Deserialize; +use serde::Serialize; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub struct Span { + pub left: usize, + pub right: usize, +} + +impl Span { + pub fn new(left: usize, right: usize) -> Self { + Self { left, right } + } + + pub fn contains(&self, position: usize) -> bool { + self.left < position && position < self.right + } +} diff --git a/crates/air-lib/air-parser/src/parser/tests/ap.rs b/crates/air-lib/air-parser/src/parser/tests/ap.rs index 3e3a5cd9..98f5a0f5 100644 --- a/crates/air-lib/air-parser/src/parser/tests/ap.rs +++ b/crates/air-lib/air-parser/src/parser/tests/ap.rs @@ -27,7 +27,7 @@ fn ap_with_literal() { let actual = parse(source_code); let expected = ap( ApArgument::Literal("some_string"), - Variable::stream("$stream"), + Variable::stream("$stream", 27), ); assert_eq!(actual, expected); @@ -42,7 +42,7 @@ fn ap_with_number() { let actual = parse(source_code); let expected = ap( ApArgument::Number(Number::Int(-100)), - Variable::stream("$stream"), + Variable::stream("$stream", 18), ); assert_eq!(actual, expected); @@ -55,7 +55,7 @@ fn ap_with_bool() { "#; let actual = parse(source_code); - let expected = ap(ApArgument::Boolean(true), Variable::stream("$stream")); + let expected = ap(ApArgument::Boolean(true), Variable::stream("$stream", 18)); assert_eq!(actual, expected); } @@ -69,7 +69,7 @@ fn ap_with_last_error() { let actual = parse(source_code); let expected = ap( ApArgument::LastError(LastErrorPath::Message), - Variable::stream("$stream"), + Variable::stream("$stream", 33), ); assert_eq!(actual, expected); diff --git a/crates/air-lib/air-parser/src/parser/tests/call.rs b/crates/air-lib/air-parser/src/parser/tests/call.rs index a0a7c650..0119cfc8 100644 --- a/crates/air-lib/air-parser/src/parser/tests/call.rs +++ b/crates/air-lib/air-parser/src/parser/tests/call.rs @@ -35,14 +35,15 @@ fn parse_json_path() { CallInstrValue::Variable(VariableWithLambda::from_raw_lambda_scalar( "peer_id", vec![ValueAccessor::FieldAccess { field_name: "a" }], + 15, )), CallInstrValue::Literal("service_id"), CallInstrValue::Literal("function_name"), Rc::new(vec![ Value::Literal("hello"), - Value::Variable(VariableWithLambda::scalar("name")), + Value::Variable(VariableWithLambda::scalar("name", 68)), ]), - CallOutputValue::Variable(Variable::stream("$void")), + CallOutputValue::Variable(Variable::stream("$void", 74)), ); assert_eq!(instruction, expected); } @@ -55,13 +56,13 @@ fn parse_empty_array() { let actual = parse(source_code); let expected = call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer_id")), - CallInstrValue::Variable(VariableWithLambda::scalar("service_id")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer_id", 15)), + CallInstrValue::Variable(VariableWithLambda::scalar("service_id", 24)), CallInstrValue::Literal("function_name"), Rc::new(vec![ Value::Literal(""), Value::EmptyArray, - Value::Variable(VariableWithLambda::scalar("arg")), + Value::Variable(VariableWithLambda::scalar("arg", 59)), ]), CallOutputValue::None, ); @@ -77,11 +78,11 @@ fn parse_empty_array_2() { let actual = parse(source_code); let expected = call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer_id")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer_id", 15)), CallInstrValue::Literal("service_id"), CallInstrValue::Literal("function_name"), Rc::new(vec![ - Value::Variable(VariableWithLambda::scalar("k")), + Value::Variable(VariableWithLambda::scalar("k", 55)), Value::EmptyArray, Value::EmptyArray, ]), @@ -206,11 +207,12 @@ fn parse_json_path_complex() { CallInstrValue::Variable(VariableWithLambda::from_raw_lambda_scalar( "m", vec![ValueAccessor::ArrayAccess { idx: 1 }], + 32, )), CallInstrValue::Literal("service_id"), CallInstrValue::Literal("function_name"), Rc::new(vec![]), - CallOutputValue::Variable(Variable::scalar("void")), + CallOutputValue::Variable(Variable::scalar("void", 75)), ), call( CallInstrValue::Variable(VariableWithLambda::from_raw_lambda_scalar( @@ -224,11 +226,12 @@ fn parse_json_path_complex() { ValueAccessor::FieldAccess { field_name: "cde" }, ValueAccessor::ArrayAccess { idx: 1 }, ], + 99, )), CallInstrValue::Literal("service_id"), CallInstrValue::Literal("function_name"), Rc::new(vec![]), - CallOutputValue::Variable(Variable::scalar("void")), + CallOutputValue::Variable(Variable::scalar("void", 162)), ), ); assert_eq!(instruction, expected); @@ -246,6 +249,7 @@ fn json_path_square_braces() { vec![ValueAccessor::FieldAccess { field_name: "peer_id", }], + 15, )), CallInstrValue::Literal("return"), CallInstrValue::Literal(""), @@ -259,13 +263,15 @@ fn json_path_square_braces() { ValueAccessor::ArrayAccess { idx: 0 }, ValueAccessor::FieldAccess { field_name: "abc" }, ], + 43, )), Value::Variable(VariableWithLambda::from_raw_lambda_scalar( "u", vec![ValueAccessor::FieldAccess { field_name: "name" }], + 64, )), ]), - CallOutputValue::Variable(Variable::stream("$void")), + CallOutputValue::Variable(Variable::stream("$void", 74)), ); assert_eq!(instruction, expected); @@ -352,14 +358,14 @@ fn seq_par_call() { CallInstrValue::Literal("local_service_id"), CallInstrValue::Literal("local_fn_name"), Rc::new(vec![]), - CallOutputValue::Variable(Variable::scalar("result_1")), + CallOutputValue::Variable(Variable::scalar("result_1", 108)), ), call( CallInstrValue::Literal(peer_id), CallInstrValue::Literal("service_id"), CallInstrValue::Literal("fn_name"), Rc::new(vec![]), - CallOutputValue::Variable(Variable::scalar("g")), + CallOutputValue::Variable(Variable::scalar("g", 183)), ), ), call( @@ -367,7 +373,7 @@ fn seq_par_call() { CallInstrValue::Literal("local_service_id"), CallInstrValue::Literal("local_fn_name"), Rc::new(vec![]), - CallOutputValue::Variable(Variable::scalar("result_2")), + CallOutputValue::Variable(Variable::scalar("result_2", 273)), ), ); @@ -407,14 +413,14 @@ fn seq_with_empty_and_dash() { CallInstrValue::Literal(""), CallInstrValue::Literal(""), Rc::new(vec![Value::Literal("module-bytes")]), - CallOutputValue::Variable(Variable::scalar("module-bytes")), + CallOutputValue::Variable(Variable::scalar("module-bytes", 119)), ), call( CallInstrValue::Literal("set_variables"), CallInstrValue::Literal(""), CallInstrValue::Literal(""), Rc::new(vec![Value::Literal("module_config")]), - CallOutputValue::Variable(Variable::scalar("module_config")), + CallOutputValue::Variable(Variable::scalar("module_config", 201)), ), ), call( @@ -422,7 +428,7 @@ fn seq_with_empty_and_dash() { CallInstrValue::Literal(""), CallInstrValue::Literal(""), Rc::new(vec![Value::Literal("blueprint")]), - CallOutputValue::Variable(Variable::scalar("blueprint")), + CallOutputValue::Variable(Variable::scalar("blueprint", 294)), ), ), seq( @@ -431,10 +437,10 @@ fn seq_with_empty_and_dash() { CallInstrValue::Literal("add_module"), CallInstrValue::Literal(""), Rc::new(vec![ - Value::Variable(VariableWithLambda::scalar("module-bytes")), - Value::Variable(VariableWithLambda::scalar("module_config")), + Value::Variable(VariableWithLambda::scalar("module-bytes", 381)), + Value::Variable(VariableWithLambda::scalar("module_config", 394)), ]), - CallOutputValue::Variable(Variable::scalar("module")), + CallOutputValue::Variable(Variable::scalar("module", 409)), ), seq( Instruction::Call(Call { @@ -445,8 +451,9 @@ fn seq_with_empty_and_dash() { }, args: Rc::new(vec![Value::Variable(VariableWithLambda::scalar( "blueprint", + 490, ))]), - output: CallOutputValue::Variable(Variable::scalar("blueprint_id")), + output: CallOutputValue::Variable(Variable::scalar("blueprint_id", 501)), }), seq( call( @@ -455,8 +462,9 @@ fn seq_with_empty_and_dash() { CallInstrValue::Literal(""), Rc::new(vec![Value::Variable(VariableWithLambda::scalar( "blueprint_id", + 589, ))]), - CallOutputValue::Variable(Variable::scalar("service_id")), + CallOutputValue::Variable(Variable::scalar("service_id", 603)), ), call( CallInstrValue::Literal("remote_peer_id"), @@ -464,8 +472,9 @@ fn seq_with_empty_and_dash() { CallInstrValue::Literal(""), Rc::new(vec![Value::Variable(VariableWithLambda::scalar( "service_id", + 671, ))]), - CallOutputValue::Variable(Variable::scalar("client_result")), + CallOutputValue::Variable(Variable::scalar("client_result", 683)), ), ), ), @@ -484,9 +493,9 @@ fn no_output() { let actual = parse(source_code); let expected = call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer")), - CallInstrValue::Variable(VariableWithLambda::scalar("service")), - CallInstrValue::Variable(VariableWithLambda::scalar("fname")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer", 15)), + CallInstrValue::Variable(VariableWithLambda::scalar("service", 21)), + CallInstrValue::Variable(VariableWithLambda::scalar("fname", 29)), Rc::new(vec![]), CallOutputValue::None, ); diff --git a/crates/air-lib/air-parser/src/parser/tests/dsl.rs b/crates/air-lib/air-parser/src/parser/tests/dsl.rs index a4b57bf7..9ad8d67e 100644 --- a/crates/air-lib/air-parser/src/parser/tests/dsl.rs +++ b/crates/air-lib/air-parser/src/parser/tests/dsl.rs @@ -53,31 +53,47 @@ pub(super) fn seqnn() -> Instruction<'static> { seq(null(), null()) } +pub(super) fn new<'i>( + variable: Variable<'i>, + instruction: Instruction<'i>, + span: Span, +) -> Instruction<'i> { + Instruction::New(New { + variable, + instruction: Box::new(instruction), + span, + }) +} + pub(super) fn null() -> Instruction<'static> { Instruction::Null(Null) } pub(super) fn fold_scalar<'a>( iterable: ScalarWithLambda<'a>, - iterator: &'a str, + iterator: Scalar<'a>, instruction: Instruction<'a>, + span: Span, ) -> Instruction<'a> { Instruction::FoldScalar(FoldScalar { iterable, - iterator: Scalar::new(iterator), + iterator, instruction: std::rc::Rc::new(instruction), + span, }) } pub(super) fn fold_stream<'a>( - stream_name: &'a str, - iterator: &'a str, + iterable: Stream<'a>, + iterator: Scalar<'a>, instruction: Instruction<'a>, + span: Span, ) -> Instruction<'a> { Instruction::FoldStream(FoldStream { - iterable: Stream::new(stream_name), - iterator: Scalar::new(iterator), + iterable, + iterator, instruction: std::rc::Rc::new(instruction), + span, }) } diff --git a/crates/air-lib/air-parser/src/parser/tests/fold.rs b/crates/air-lib/air-parser/src/parser/tests/fold.rs index 7c65a56f..8f04d980 100644 --- a/crates/air-lib/air-parser/src/parser/tests/fold.rs +++ b/crates/air-lib/air-parser/src/parser/tests/fold.rs @@ -67,7 +67,12 @@ fn parse_fold() { ) "#; let instruction = parse(&source_code); - let expected = fold_scalar(ScalarWithLambda::new("iterable", None), "i", null()); + let expected = fold_scalar( + ScalarWithLambda::new("iterable", None, 15), + Scalar::new("i", 24), + null(), + Span::new(9, 54), + ); assert_eq!(instruction, expected); } @@ -84,9 +89,11 @@ fn fold_json_path() { ScalarWithLambda::from_raw_lambda( "members", vec![ValueAccessor::ArrayAccess { idx: 123321 }], + 33, ), - "m", + Scalar::new("m", 52), null(), + Span::new(27, 61), ); assert_eq!(instruction, expected); } @@ -98,7 +105,12 @@ fn fold_on_stream() { "#; let instruction = parse(source_code); - let expected = fold_stream("$stream", "iterator", null()); + let expected = fold_stream( + Stream::new("$stream", 15), + Scalar::new("iterator", 23), + null(), + Span::new(9, 39), + ); assert_eq!(instruction, expected); } @@ -119,9 +131,11 @@ fn comments() { }, ValueAccessor::ArrayAccess { idx: 1 }, ], + 33, ), - "m", + Scalar::new("m", 52), null(), + Span::new(27, 61), ); assert_eq!(instruction, expected); } @@ -138,9 +152,10 @@ fn parse_fold_with_xor_par_seq() { let instruction = parse(&source_code); let instr = binary_instruction(*name); let expected = fold_scalar( - ScalarWithLambda::new("iterable", None), - "i", + ScalarWithLambda::new("iterable", None, 6), + Scalar::new("i", 15), instr(null(), null()), + Span::new(0, 58), ); assert_eq!(instruction, expected); } diff --git a/crates/air-lib/air-parser/src/parser/tests/match_.rs b/crates/air-lib/air-parser/src/parser/tests/match_.rs index ee58fd58..66b9f695 100644 --- a/crates/air-lib/air-parser/src/parser/tests/match_.rs +++ b/crates/air-lib/air-parser/src/parser/tests/match_.rs @@ -27,8 +27,8 @@ fn parse_match() { "#; let instruction = parse(&source_code); let expected = match_( - Value::Variable(VariableWithLambda::scalar("v1")), - Value::Variable(VariableWithLambda::scalar("v2")), + Value::Variable(VariableWithLambda::scalar("v1", 16)), + Value::Variable(VariableWithLambda::scalar("v2", 19)), null(), ); assert_eq!(instruction, expected); @@ -43,7 +43,7 @@ fn parse_match_with_init_peer_id() { "#; let instruction = parse(&source_code); let expected = match_( - Value::Variable(VariableWithLambda::scalar("v1")), + Value::Variable(VariableWithLambda::scalar("v1", 16)), Value::InitPeerId, null(), ); @@ -59,8 +59,8 @@ fn parse_mismatch() { "#; let instruction = parse(&source_code); let expected = mismatch( - Value::Variable(VariableWithLambda::scalar("v1")), - Value::Variable(VariableWithLambda::scalar("v2")), + Value::Variable(VariableWithLambda::scalar("v1", 19)), + Value::Variable(VariableWithLambda::scalar("v2", 22)), null(), ); assert_eq!(instruction, expected); @@ -74,7 +74,7 @@ fn match_with_bool() { ) "#; - let left_value = Value::Variable(VariableWithLambda::scalar("isOnline")); + let left_value = Value::Variable(VariableWithLambda::scalar("isOnline", 17)); let right_value = Value::Boolean(true); let null = null(); let expected = match_(left_value, right_value, null); @@ -92,7 +92,7 @@ fn mismatch_with_bool() { "#; let left_value = Value::Boolean(true); - let right_value = Value::Variable(VariableWithLambda::scalar("isOnline")); + let right_value = Value::Variable(VariableWithLambda::scalar("isOnline", 25)); let null = null(); let expected = mismatch(left_value, right_value, null); diff --git a/crates/air-lib/air-parser/src/parser/tests/mod.rs b/crates/air-lib/air-parser/src/parser/tests/mod.rs index 7fee17dc..25dca187 100644 --- a/crates/air-lib/air-parser/src/parser/tests/mod.rs +++ b/crates/air-lib/air-parser/src/parser/tests/mod.rs @@ -19,6 +19,7 @@ mod call; mod dsl; mod fold; mod match_; +mod new; mod null; mod par; mod seq; diff --git a/crates/air-lib/air-parser/src/parser/tests/new.rs b/crates/air-lib/air-parser/src/parser/tests/new.rs new file mode 100644 index 00000000..86c05830 --- /dev/null +++ b/crates/air-lib/air-parser/src/parser/tests/new.rs @@ -0,0 +1,84 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use super::dsl::*; +use super::parse; +use crate::ast::*; +use crate::parser::ParserError; + +use lalrpop_util::ParseError; + +#[test] +fn parse_new_with_scalar() { + let source_code = r#"(new scalar + (null) + ) + "#; + + let instruction = parse(source_code); + let expected = new(Variable::scalar("scalar", 5), null(), Span::new(0, 40)); + assert_eq!(instruction, expected); +} + +#[test] +fn parse_new_with_stream() { + let source_code = r#"(new $stream + (null) + ) + "#; + + let instruction = parse(source_code); + let expected = new(Variable::stream("$stream", 5), null(), Span::new(0, 41)); + assert_eq!(instruction, expected); +} + +#[test] +fn iterators_cant_be_restricted() { + let source_code = r#" + (seq + (call "" ("" "") [] iterable) + (fold iterable iterator + (new iterator + (call "" ("" "") [iterator]) + ) + ) + ) + "#; + + let lexer = crate::AIRLexer::new(source_code); + + let parser = crate::AIRParser::new(); + let mut errors = Vec::new(); + let mut validator = crate::parser::VariableValidator::new(); + parser + .parse(source_code, &mut errors, &mut validator, lexer) + .expect("parser shouldn't fail"); + + let errors = validator.finalize(); + + assert_eq!(errors.len(), 1); + println!("{:?}", errors); + let error = &errors[0].error; + let parser_error = match error { + ParseError::User { error } => error, + _ => panic!("unexpected error type"), + }; + + assert!(matches!( + parser_error, + ParserError::IteratorRestrictionNotAllowed(..) + )); +} diff --git a/crates/air-lib/air-parser/src/parser/tests/seq.rs b/crates/air-lib/air-parser/src/parser/tests/seq.rs index a24fb25c..7784dbe3 100644 --- a/crates/air-lib/air-parser/src/parser/tests/seq.rs +++ b/crates/air-lib/air-parser/src/parser/tests/seq.rs @@ -32,11 +32,11 @@ fn parse_seq() { let instruction = parse(source_code); let expected = seq( call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer_id")), - CallInstrValue::Variable(VariableWithLambda::scalar("service_id")), - CallInstrValue::Variable(VariableWithLambda::scalar("function_name")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer_id", 32)), + CallInstrValue::Variable(VariableWithLambda::scalar("service_id", 41)), + CallInstrValue::Variable(VariableWithLambda::scalar("function_name", 52)), Rc::new(vec![Value::EmptyArray, Value::EmptyArray]), - CallOutputValue::Variable(Variable::scalar("output")), + CallOutputValue::Variable(Variable::scalar("output", 75)), ), call( CallInstrValue::Literal("peer_id"), @@ -45,7 +45,7 @@ fn parse_seq() { Rc::new(vec![ Value::Literal("hello"), Value::EmptyArray, - Value::Variable(VariableWithLambda::scalar("name")), + Value::Variable(VariableWithLambda::scalar("name", 154)), ]), CallOutputValue::None, ), @@ -68,16 +68,16 @@ fn parse_seq_seq() { let expected = seq( seq( call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer_id")), - CallInstrValue::Variable(VariableWithLambda::scalar("service_id")), - CallInstrValue::Variable(VariableWithLambda::scalar("function_name")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer_id", 53)), + CallInstrValue::Variable(VariableWithLambda::scalar("service_id", 62)), + CallInstrValue::Variable(VariableWithLambda::scalar("function_name", 073)), Rc::new(vec![]), CallOutputValue::None, ), call( - CallInstrValue::Variable(VariableWithLambda::scalar("peer_id")), + CallInstrValue::Variable(VariableWithLambda::scalar("peer_id", 115)), CallInstrValue::Literal("service_B"), - CallInstrValue::Variable(VariableWithLambda::scalar("function_name")), + CallInstrValue::Variable(VariableWithLambda::scalar("function_name", 147)), Rc::new(vec![]), CallOutputValue::None, ), @@ -88,9 +88,9 @@ fn parse_seq_seq() { CallInstrValue::Literal("function_name"), Rc::new(vec![ Value::Literal("hello"), - Value::Variable(VariableWithLambda::scalar("name")), + Value::Variable(VariableWithLambda::scalar("name", 248)), ]), - CallOutputValue::Variable(Variable::stream("$output")), + CallOutputValue::Variable(Variable::stream("$output", 254)), ), ); assert_eq!(instruction, expected); diff --git a/crates/air-lib/air-parser/src/parser/validator.rs b/crates/air-lib/air-parser/src/parser/validator.rs index a5bd2e81..1864f0cb 100644 --- a/crates/air-lib/air-parser/src/parser/validator.rs +++ b/crates/air-lib/air-parser/src/parser/validator.rs @@ -47,6 +47,9 @@ pub struct VariableValidator<'i> { /// Contains all met iterable in call and next, they will be resolved after the whole parsing /// due to the way how lalrpop work. unresolved_iterables: MultiMap<&'i str, Span>, + + /// Contains all names that should be checked that they are not iterators. + check_for_non_iterators: Vec<(&'i str, Span)>, } impl<'i> VariableValidator<'i> { @@ -87,6 +90,13 @@ impl<'i> VariableValidator<'i> { self.met_iterator_definition(&fold.iterator, span); } + pub(super) fn met_new(&mut self, new: &New<'i>, span: Span) { + self.check_for_non_iterators + .push((variable_name(&new.variable), span)); + // new defines a new variable + self.met_variable_definition(&new.variable, span); + } + pub(super) fn met_next(&mut self, next: &Next<'i>, span: Span) { let iterable_name = next.iterator.name; // due to the right to left convolution in lalrpop, a next instruction will be met earlier @@ -124,6 +134,12 @@ impl<'i> VariableValidator<'i> { } } + for (name, span) in self.check_for_non_iterators.iter() { + if self.contains_iterable(name, *span) { + add_to_errors(*name, &mut errors, *span, Token::New); + } + } + errors } @@ -254,6 +270,9 @@ fn add_to_errors<'err, 'i>( let variable_name = variable_name.into(); let error = match token { Token::Next => ParserError::UndefinedIterable(span.left, span.right, variable_name), + Token::New => { + ParserError::IteratorRestrictionNotAllowed(span.left, span.right, variable_name) + } _ => ParserError::UndefinedVariable(span.left, span.right, variable_name), }; let error = ParseError::User { error }; diff --git a/crates/air-lib/execution-info-collector/src/instructions_tracker.rs b/crates/air-lib/execution-info-collector/src/instructions_tracker.rs index 3e2e3a32..9f85f9c8 100644 --- a/crates/air-lib/execution-info-collector/src/instructions_tracker.rs +++ b/crates/air-lib/execution-info-collector/src/instructions_tracker.rs @@ -14,6 +14,8 @@ * limitations under the License. */ +use std::collections::HashMap; + /// Intended to track a number of executed instruction of each type. For instructions that /// have a corresponding state in data, it tracks number of executed instructions on /// current peer (executed) and overall number (seen) of met instructions of such type. @@ -24,6 +26,7 @@ pub struct InstructionTracker { pub fold: FoldTracker, pub match_count: u32, pub mismatch_count: u32, + pub new_tracker: NewTracker, pub next_count: u32, pub null_count: u32, pub par: ParTracker, @@ -55,6 +58,14 @@ pub struct ParTracker { pub executed_count: u32, } +#[derive(Default, Debug, PartialEq, Eq)] +pub struct NewTracker { + /// Mapping from a new instruction position in a script + /// to a number of their execution. This is needed to + /// support private stream generation mappings. + pub executed_count: HashMap, +} + impl InstructionTracker { pub fn meet_ap(&mut self) { self.ap.seen_count += 1; @@ -111,4 +122,24 @@ impl InstructionTracker { pub fn meet_xor(&mut self) { self.xor_count += 1; } + + pub fn meet_new(&mut self, position: usize) { + use std::collections::hash_map::Entry::{Occupied, Vacant}; + + match self.new_tracker.executed_count.entry(position) { + Occupied(mut entry) => *entry.get_mut() += 1, + Vacant(entry) => { + entry.insert(1); + } + }; + } +} + +impl NewTracker { + pub fn get_iteration(&self, position: usize) -> u32 { + self.executed_count + .get(&position) + .copied() + .unwrap_or_default() + } } diff --git a/crates/air-lib/interpreter-data/CHANGELOG.md b/crates/air-lib/interpreter-data/CHANGELOG.md index 79e7f05f..74f1010a 100644 --- a/crates/air-lib/interpreter-data/CHANGELOG.md +++ b/crates/air-lib/interpreter-data/CHANGELOG.md @@ -1,3 +1,8 @@ +## Version 0.2.2 + +[PR 169](https://github.com/fluencelabs/aquavm/pull/169): +- added a new field for tracking generations of private streams + ## Version 0.2.1 [PR 130](https://github.com/fluencelabs/aquavm/pull/130): diff --git a/crates/air-lib/interpreter-data/Cargo.toml b/crates/air-lib/interpreter-data/Cargo.toml index 858260d7..daab6eaa 100644 --- a/crates/air-lib/interpreter-data/Cargo.toml +++ b/crates/air-lib/interpreter-data/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "air-interpreter-data" description = "Data format of the AIR interpreter" -version = "0.2.0" +version = "0.2.2" authors = ["Fluence Labs"] edition = "2018" license = "Apache-2.0" diff --git a/crates/air-lib/interpreter-data/src/interpreter_data.rs b/crates/air-lib/interpreter-data/src/interpreter_data.rs index c8a34bf4..05ff8099 100644 --- a/crates/air-lib/interpreter-data/src/interpreter_data.rs +++ b/crates/air-lib/interpreter-data/src/interpreter_data.rs @@ -15,13 +15,13 @@ */ use super::ExecutedState; +use super::GlobalStreamGens; +use super::RestrictedStreamGens; use super::DATA_FORMAT_VERSION; use serde::Deserialize; use serde::Serialize; -use std::collections::HashMap; use std::ops::Deref; -pub type StreamGenerations = HashMap; pub type ExecutionTrace = Vec; /// The AIR interpreter could be considered as a function @@ -33,9 +33,11 @@ pub struct InterpreterData { /// Trace of AIR execution, which contains executed call, par and fold states. pub trace: ExecutionTrace, - /// Contains maximum generation for each stream. This info will be used while merging - /// values in streams. - pub streams: StreamGenerations, + /// Contains maximum generation for each global stream. This info will be used while merging + /// values in streams. This field is also needed for backward compatibility with + /// <= 0.2.1 versions. + #[serde(rename = "streams")] // for compatibility with versions <= 0.2.1 + pub global_streams: GlobalStreamGens, /// Version of this data format. pub version: semver::Version, @@ -44,28 +46,37 @@ pub struct InterpreterData { #[serde(default)] #[serde(rename = "lcid")] pub last_call_request_id: u32, + + /// Contains maximum generation for each private stream. This info will be used while merging + /// values in streams. + #[serde(default)] + #[serde(rename = "r_streams")] + pub restricted_streams: RestrictedStreamGens, } impl InterpreterData { pub fn new() -> Self { Self { trace: <_>::default(), - streams: <_>::default(), + global_streams: <_>::default(), version: DATA_FORMAT_VERSION.deref().clone(), last_call_request_id: 0, + restricted_streams: <_>::default(), } } pub fn from_execution_result( trace: ExecutionTrace, - streams: StreamGenerations, + streams: GlobalStreamGens, + restricted_streams: RestrictedStreamGens, last_call_request_id: u32, ) -> Self { Self { trace, - streams, + global_streams: streams, version: DATA_FORMAT_VERSION.deref().clone(), last_call_request_id, + restricted_streams, } } @@ -98,14 +109,14 @@ mod tests { #[derive(Serialize, Deserialize)] struct InterpreterData0_2_0 { pub trace: ExecutionTrace, - pub streams: StreamGenerations, + pub streams: GlobalStreamGens, pub version: semver::Version, } - // test 0.2.0 to 0.2.1 conversion + // test 0.2.0 to 0.2.2 conversion let data_0_2_0 = InterpreterData0_2_0 { trace: ExecutionTrace::default(), - streams: StreamGenerations::default(), + streams: GlobalStreamGens::default(), version: semver::Version::new(0, 2, 0), }; @@ -113,10 +124,41 @@ mod tests { let data_0_2_1 = serde_json::from_slice::(&data_0_2_0_se); assert!(data_0_2_1.is_ok()); - // test 0.2.1 to 0.2.1 conversion - let data_0_2_1 = InterpreterData::default(); + // test 0.2.2 to 0.2.0 conversion + let data_0_2_2 = InterpreterData::default(); + let data_0_2_2_se = serde_json::to_vec(&data_0_2_2).unwrap(); + let data_0_2_0 = serde_json::from_slice::(&data_0_2_2_se); + assert!(data_0_2_0.is_ok()); + } + + #[test] + fn compatible_with_0_2_1_version() { + #[derive(Serialize, Deserialize)] + struct InterpreterData0_2_1 { + pub trace: ExecutionTrace, + pub streams: GlobalStreamGens, + pub version: semver::Version, + #[serde(default)] + #[serde(rename = "lcid")] + pub last_call_request_id: u32, + } + + // test 0.2.1 to 0.2.2 conversion + let data_0_2_1 = InterpreterData0_2_1 { + trace: ExecutionTrace::default(), + streams: GlobalStreamGens::default(), + version: semver::Version::new(0, 2, 1), + last_call_request_id: 1, + }; + let data_0_2_1_se = serde_json::to_vec(&data_0_2_1).unwrap(); - let data_0_2_0 = serde_json::from_slice::(&data_0_2_1_se); + let data_0_2_2 = serde_json::from_slice::(&data_0_2_1_se); + assert!(data_0_2_2.is_ok()); + + // test 0.2.2 to 0.2.1 conversion + let data_0_2_2 = InterpreterData::default(); + let data_0_2_2_se = serde_json::to_vec(&data_0_2_2).unwrap(); + let data_0_2_0 = serde_json::from_slice::(&data_0_2_2_se); assert!(data_0_2_0.is_ok()); } } diff --git a/crates/air-lib/interpreter-data/src/lib.rs b/crates/air-lib/interpreter-data/src/lib.rs index 6de65a69..13ef778b 100644 --- a/crates/air-lib/interpreter-data/src/lib.rs +++ b/crates/air-lib/interpreter-data/src/lib.rs @@ -14,15 +14,28 @@ * limitations under the License. */ +#![warn(rust_2018_idioms)] +#![deny( + dead_code, + nonstandard_style, + unused_imports, + unused_mut, + unused_variables, + unused_unsafe, + unreachable_patterns +)] + mod executed_state; mod interpreter_data; +mod stream_generations; pub use executed_state::*; pub use interpreter_data::*; +pub use stream_generations::*; use once_cell::sync::Lazy; use std::str::FromStr; pub static DATA_FORMAT_VERSION: Lazy = Lazy::new(|| { - semver::Version::from_str("0.2.1").expect("invalid data format version specified") + semver::Version::from_str("0.2.2").expect("invalid data format version specified") }); diff --git a/crates/air-lib/interpreter-data/src/stream_generations.rs b/crates/air-lib/interpreter-data/src/stream_generations.rs new file mode 100644 index 00000000..cc3d568f --- /dev/null +++ b/crates/air-lib/interpreter-data/src/stream_generations.rs @@ -0,0 +1,31 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use std::collections::HashMap; + +/// Mapping from a stream name to it's generation count. +/// Similar to pi-calculus non-restricted names/channels. +pub type GlobalStreamGens = HashMap; + +/// Mapping from a stream name to +/// position of a new instruction in a script that creates a scope for a stream +/// to vector where each position represents a corresponding iteration. +/// +/// Vec is needed because a new instruction could be placed into a fold instruction, +/// so it could be met several times during script execution. This field anchors iteration +/// where it was met. +/// Similar to pi-calculus restricted names/channels. +pub type RestrictedStreamGens = HashMap>>; diff --git a/crates/air-lib/test-utils/src/executed_state.rs b/crates/air-lib/test-utils/src/executed_state.rs index 2f44d1b2..951c49ba 100644 --- a/crates/air-lib/test-utils/src/executed_state.rs +++ b/crates/air-lib/test-utils/src/executed_state.rs @@ -33,7 +33,14 @@ pub fn scalar(result: JValue) -> ExecutedState { ExecutedState::Call(CallResult::Executed(value)) } -pub fn stream_jvalue(result: JValue, generation: u32) -> ExecutedState { +pub fn scalar_number(result: impl Into) -> ExecutedState { + let result = JValue::Number(result.into()); + let value = Rc::new(result); + + ExecutedState::Call(CallResult::executed_scalar(value)) +} + +pub fn stream(result: JValue, generation: u32) -> ExecutedState { let call_result = CallResult::executed_stream(Rc::new(result), generation); ExecutedState::Call(call_result) } diff --git a/crates/air-lib/test-utils/src/lib.rs b/crates/air-lib/test-utils/src/lib.rs index cd557797..4b3602a3 100644 --- a/crates/air-lib/test-utils/src/lib.rs +++ b/crates/air-lib/test-utils/src/lib.rs @@ -82,7 +82,7 @@ pub fn data_from_result(result: &RawAVMOutcome) -> InterpreterData { } pub fn raw_data_from_trace(trace: ExecutionTrace) -> Vec { - let data = InterpreterData::from_execution_result(trace, <_>::default(), 0); + let data = InterpreterData::from_execution_result(trace, <_>::default(), <_>::default(), 0); serde_json::to_vec(&data).expect("default serializer shouldn't fail") } diff --git a/crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs b/crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs index a5213ef2..8297b80d 100644 --- a/crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs +++ b/crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs @@ -19,8 +19,8 @@ use super::KeeperError; use super::KeeperResult; use super::TraceSlider; +use air_interpreter_data::GlobalStreamGens; use air_interpreter_data::InterpreterData; -use air_interpreter_data::StreamGenerations; use std::collections::HashMap; @@ -28,7 +28,7 @@ use std::collections::HashMap; #[derive(Debug, Default, PartialEq)] pub struct MergeCtx { pub slider: TraceSlider, - pub streams: StreamGenerations, + pub streams: GlobalStreamGens, } impl MergeCtx { @@ -47,7 +47,7 @@ impl MergeCtx { Self { slider, - streams: data.streams, + streams: data.global_streams, } }