From 54b1af8d1436b11003fb67991dbcf9cea3596b20 Mon Sep 17 00:00:00 2001 From: jasisz Date: Fri, 25 Sep 2026 10:02:08 +0200 Subject: [PATCH] Take records by value in the wrappers of mutual tail-call groups The public function of a mutual tail-call group borrowed every record, collection or other non-copy argument and cloned it into the trampoline state. The caller's value lived on during the call, so the first in-place update of a Map inside it (Map.set on pool.seen) copied the whole Map, once per call. compute_owned_record_params skipped these members, so no caller ever handed them its value. The trampoline holds its params by value anyway, so the wrapper now takes them by value too, except the group's invariants, which every member hands on unchanged and the trampoline reads through a borrow for the whole run. The facts go into rust_owned_record_params for the members, so call sites, function-value adapters and the callers' own by-value graduation all read the same decision: a caller at its last use moves the value in, one that keeps it clones at the call instead of in the wrapper, which costs the same. Co-Authored-By: Claude Opus 5.5 (1M context) --- CHANGELOG.md | 1 + src/codegen/rust/expr.rs | 5 +- src/codegen/rust/from_mir.rs | 77 +- .../aver_generated/domain/builtins/mod.rs | 20 +- .../aver_generated/domain/eval/core/mod.rs | 1075 ++++++++--------- .../aver_generated/domain/match_mod/mod.rs | 34 +- .../aver_generated/domain/parser/expr/mod.rs | 223 ++-- .../aver_generated/domain/parser/mod.rs | 99 +- .../aver_generated/domain/parser_match/mod.rs | 38 +- .../domain/resolver/core/mod.rs | 44 +- src/self_host/aver_generated/entry/mod.rs | 31 +- .../fixtures/rust_mutual_tco_by_value/main.av | 55 + tests/rust_work_spec.rs | 43 + 13 files changed, 896 insertions(+), 849 deletions(-) create mode 100644 tests/fixtures/rust_mutual_tco_by_value/main.av diff --git a/CHANGELOG.md b/CHANGELOG.md index 660a39fdc..ee3b64ae2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -54,6 +54,7 @@ The generated loop is now written from the program's source alone, and the manif ### Fixed +- **Generated Rust hands a record to functions that tail-call each other without copying it.** The public function of such a group borrowed a record or collection argument and cloned it into the loop that runs the group, so while the caller still held its copy, the first `Map.set` on a Map inside it copied the whole Map, once per call. It now takes the argument by value, and a caller at its last use moves it in; a caller that keeps it clones at the call, as the function did before. An argument every function of the group passes on unchanged is still borrowed. A loop handing a pool with a million-entry Map to such a pair 100 times ran in 0.64 s and now runs in 0.07 s. - **wasm-gc: `Map.set` no longer copies the map, and `Map.remove` no longer changes the map it was given.** `set` copied every bucket unless the compiler could prove the map had no other holder, which it cannot for a map held in a record field such as an answer module's state. A 100 000-entry state map served 2000 `Map.set` requests in 11 s under `aver run --wasm-gc` and 1.9 s on Node 26. `remove` wrote into the map it was given, so a caller that still held that map saw the key gone. Both now write into the map's arrays in place and return a new version. The version they were given stays valid, because a record of what the write replaced is kept with it. The same run now takes 0.4 s under `aver run --wasm-gc` and 0.3 s on Node. Reading an older version again costs one step for each write made since. - **A program with the generated loop can key its own waits by a type of its own.** The loop keys its wait by `Int`, and a hand-written `Wait.poll` keyed by a sum beside it used to be refused by the Rust door ("this program keys one wait set by 'Int' and another by 'Watch'") and to fail wasm-gc validation. In a program that answers a capability of its own, each such wait, in the entry or in a dependency, now goes through helpers generated for its key type that carry it through an `Int`-keyed wait. It answers the same keys in the same order. Its recording holds the `Int`-keyed wait. The wasm-gc wait ABI is unchanged, and `--target wasip2` runs such waits too. A program that answers no capability still keys all its waits one way. - **`check` no longer asks a verify block of a function no verify case can call.** A parameter of a capability resource type (`Tcp.Connection`, `Work.Job`, a job kind's handle), or of a tuple, record or sum of the module that always carries one, has no value a case can write, so such a pure branching helper failed `error[missing-verify]` with no way to satisfy it. It is now exempt, the way effectful functions are. A parameter with an empty value (`List`, `Option`, a sum with a resource-free variant) still needs its verify block. diff --git a/src/codegen/rust/expr.rs b/src/codegen/rust/expr.rs index 50009974b..69d50c3d9 100644 --- a/src/codegen/rust/expr.rs +++ b/src/codegen/rust/expr.rs @@ -187,7 +187,10 @@ pub(super) fn callee_borrow_mask(name: &str, arg_count: usize, ctx: &CodegenCont .params .iter() .take(arg_count) - .map(|(_, ty)| should_borrow_param(ty)) + .enumerate() + .map(|(i, (_, ty))| { + should_borrow_param(ty) && !super::from_mir::mutual_param_by_value(ctx, fn_id, i) + }) .collect() }; diff --git a/src/codegen/rust/from_mir.rs b/src/codegen/rust/from_mir.rs index 2eaab2c54..3e22ff358 100644 --- a/src/codegen/rust/from_mir.rs +++ b/src/codegen/rust/from_mir.rs @@ -701,6 +701,7 @@ pub(super) fn compute_owned_record_params( let Some(program) = ctx.mir_program.as_ref() else { return owned; }; + owned.extend(mutual_tco_value_params(ctx)); let mut candidates: Vec<(crate::ir::FnId, Vec)> = Vec::new(); for (id, mir_fn) in program.iter() { let Some(resolved) = ctx.resolved_program.fn_by_id(*id) else { @@ -774,6 +775,59 @@ pub(super) fn compute_owned_record_params( owned } +/// Which params of each mutual tail-call member its wrapper takes by value. +/// +/// Every arm of the trampoline holds its params by value, so a wrapper that +/// borrows a record or collection has to clone it into the trampoline's +/// state, and while the caller's copy lives every in-place update of a Map +/// in it copies the Map. Taken by value, a caller at its last use moves the +/// value in and nothing is cloned; a caller that keeps it clones at the call +/// instead of in the wrapper, which costs the same. The group's invariants +/// (params every member hands on unchanged) stay borrowed: the trampoline +/// reads them through `&T` for the whole run and never needs its own copy. +fn mutual_tco_value_params(ctx: &CodegenContext) -> HashMap> { + let members: Vec<&crate::ir::hir::ResolvedFnDef> = ctx + .mutual_tco_members + .iter() + .filter_map(|id| ctx.resolved_program.fn_by_id(*id)) + .collect(); + let mut out = HashMap::new(); + for group in crate::call_graph::tailcall_scc_components_resolved(&members) { + let invariants = super::toplevel::compute_resolved_rc_params(&group); + let invariant_names: HashSet<&str> = invariants + .iter() + .filter_map(|&i| group[0].params.get(i).map(|(name, _)| name.as_str())) + .collect(); + for fd in &group { + let by_value = fd + .params + .iter() + .map(|(name, ty)| { + should_borrow_param(ty) && !invariant_names.contains(name.as_str()) + }) + .collect(); + out.insert(fd.fn_id, by_value); + } + } + out +} + +/// Whether mutual tail-call member `fn_id` takes param `index`, which would +/// otherwise be borrowed, by value (see [`mutual_tco_value_params`]). +pub(super) fn mutual_param_by_value( + ctx: &CodegenContext, + fn_id: crate::ir::FnId, + index: usize, +) -> bool { + ctx.mutual_tco_members.contains(&fn_id) + && ctx + .rust_owned_record_params + .get(&fn_id) + .and_then(|params| params.get(index)) + .copied() + .unwrap_or(false) +} + /// What [`consumes_local`] reads besides the expression: the by-value /// callee positions so far, the body's movable projections, the Map/Vector /// params updated in place and the builtin names. @@ -2350,7 +2404,8 @@ fn adapt_first_class_fn_ref(name: &str, static_ref: String, ctx: &MirEmitCtx<'_> let borrow_mask: Vec = resolved .params .iter() - .map(|(_, ty)| should_borrow_param(ty)) + .enumerate() + .map(|(i, (_, ty))| should_borrow_param(ty) && !mutual_param_by_value(cg, fn_id, i)) .collect(); if !borrow_mask.iter().any(|borrowed| *borrowed) { return static_ref; @@ -4453,14 +4508,18 @@ pub(super) fn emit_mir_mutual_tco_block( for fd in group_fns { let fn_name = aver_name_to_rust(&fd.name); let variant = fn_name_to_variant(&fd.name); - let params = emit_resolved_fn_params(&fd.params, ctx, scope); + let by_value: Vec = (0..fd.params.len()) + .map(|i| mutual_param_by_value(ctx, fd.fn_id, i)) + .collect(); + let params = emit_resolved_fn_params(&fd.params, &by_value, ctx, scope); let variant_arg_names: Vec = fd .params .iter() - .filter(|(name, _)| !rc_names.contains(name)) - .map(|(name, ty)| { + .enumerate() + .filter(|(_, (name, _))| !rc_names.contains(name)) + .map(|(i, (name, ty))| { let rust_name = aver_name_to_rust(name); - if should_borrow_param(ty) { + if should_borrow_param(ty) && !by_value[i] { format!("{}.clone()", rust_name) } else { rust_name @@ -4539,16 +4598,20 @@ fn mutual_rc_param_sig( } } +/// A mutual tail-call wrapper's params: borrowed by default, by value where +/// `by_value` says so. fn emit_resolved_fn_params( params: &[(String, crate::types::Type)], + by_value: &[bool], ctx: &CodegenContext, scope: Option<&str>, ) -> String { params .iter() - .map(|(name, ty)| { + .enumerate() + .map(|(i, (name, ty))| { let rust_type = super::types::type_to_rust_scoped(ty, ctx, scope); - if should_borrow_param(ty) { + if should_borrow_param(ty) && !by_value.get(i).copied().unwrap_or(false) { format!("{}: &{rust_type}", explicit_parameter_pattern(name, false)) } else { format!("{}: {rust_type}", explicit_parameter_pattern(name, false)) diff --git a/src/self_host/aver_generated/domain/builtins/mod.rs b/src/self_host/aver_generated/domain/builtins/mod.rs index 8bcbfe063..b6869773f 100644 --- a/src/self_host/aver_generated/domain/builtins/mod.rs +++ b/src/self_host/aver_generated/domain/builtins/mod.rs @@ -40,23 +40,19 @@ fn __mutual_tco_trampoline_1( /// Convert list of (key, value) tuples to a Map. pub fn tuplesToMap( - items @ _: &aver_rt::AverList, - acc @ _: &aver_rt::AverMap, + items @ _: aver_rt::AverList, + acc @ _: aver_rt::AverMap, ) -> aver_rt::AverMap { - __mutual_tco_trampoline_1(__MutualTco1::TuplesToMap(items.clone(), acc.clone())) + __mutual_tco_trampoline_1(__MutualTco1::TuplesToMap(items, acc)) } /// Extract key-value from tuple parts. pub fn tuplesToMapOne( - parts @ _: &aver_rt::AverList, - rest @ _: &aver_rt::AverList, - acc @ _: &aver_rt::AverMap, + parts @ _: aver_rt::AverList, + rest @ _: aver_rt::AverList, + acc @ _: aver_rt::AverMap, ) -> aver_rt::AverMap { - __mutual_tco_trampoline_1(__MutualTco1::TuplesToMapOne( - parts.clone(), - rest.clone(), - acc.clone(), - )) + __mutual_tco_trampoline_1(__MutualTco1::TuplesToMapOne(parts, rest, acc)) } /// Dispatch qualified builtin calls to sub-module implementations. @@ -604,7 +600,7 @@ pub fn builtinMapFromList( let v @ _ = crate::aver_generated::domain::builtins::helpers::oneArg(args)?; let items @ _ = crate::aver_generated::domain::builtins::helpers::expectList(&v)?; Ok(crate::aver_generated::domain::value::Val::ValMap( - crate::aver_generated::domain::builtins::tuplesToMap(&items, &HashMap::new()), + crate::aver_generated::domain::builtins::tuplesToMap(items, HashMap::new()), )) } diff --git a/src/self_host/aver_generated/domain/eval/core/mod.rs b/src/self_host/aver_generated/domain/eval/core/mod.rs index 382aacfe8..7187e3e70 100644 --- a/src/self_host/aver_generated/domain/eval/core/mod.rs +++ b/src/self_host/aver_generated/domain/eval/core/mod.rs @@ -256,8 +256,8 @@ fn __mutual_tco_trampoline_1( let vecExpr = (*vecExpr).clone(); let idxExpr = (*idxExpr).clone(); return crate::aver_generated::domain::eval::core::evalVectorGetOrIntExpr( - &vecExpr, - &idxExpr, + vecExpr, + idxExpr, defaultValue, &env, &*fns, @@ -271,8 +271,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalIntModOrIntExpr( - &a, - &b, + a, + b, defaultValue, &env, &*fns, @@ -282,8 +282,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinop( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::BinOp::OpAdd, @@ -293,8 +293,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinop( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::BinOp::OpSub, @@ -304,8 +304,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinop( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::BinOp::OpMul, @@ -315,8 +315,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinop( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::BinOp::OpDiv, @@ -325,15 +325,15 @@ fn __mutual_tco_trampoline_1( crate::aver_generated::domain::ast::Expr::ExprNeg(inner) => { let inner = (*inner).clone(); return crate::aver_generated::domain::eval::core::evalNeg( - &inner, &env, &*fns, + inner, &env, &*fns, ); } crate::aver_generated::domain::ast::Expr::ExprEq(a, b) => { let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpEq, @@ -343,8 +343,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpNeq, @@ -360,8 +360,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpLt, @@ -371,8 +371,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpGt, @@ -382,8 +382,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpLte, @@ -393,8 +393,8 @@ fn __mutual_tco_trampoline_1( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmp( - &a, - &b, + a, + b, &env, &*fns, &crate::aver_generated::domain::ast::CmpOp::CmpGte, @@ -432,7 +432,7 @@ fn __mutual_tco_trampoline_1( crate::aver_generated::domain::ast::Expr::ExprFieldAccess(obj, field) => { let obj = (*obj).clone(); return crate::aver_generated::domain::eval::core::evalFieldAccess( - &obj, field, &env, &*fns, + obj, field, &env, &*fns, ); } crate::aver_generated::domain::ast::Expr::ExprCall(name, argExprs) => { @@ -470,7 +470,7 @@ fn __mutual_tco_trampoline_1( crate::aver_generated::domain::ast::Expr::ExprPropagate(inner) => { let inner = (*inner).clone(); return crate::aver_generated::domain::eval::core::evalPropagate( - &inner, &env, &*fns, + inner, &env, &*fns, ); } crate::aver_generated::domain::ast::Expr::ExprIndependentProduct( @@ -506,7 +506,7 @@ fn __mutual_tco_trampoline_1( ) => { crate::cancel_checkpoint(); let condV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&cond, &env, &*fns)?; + crate::aver_generated::domain::eval::core::evalExpr(cond, env.clone(), &*fns)?; match condV.clone() { crate::aver_generated::domain::value::Val::ValBool(flag) => { if flag { @@ -524,7 +524,11 @@ fn __mutual_tco_trampoline_1( } __MutualTco1::EvalMatchExpr(mut scrutinee @ _, mut arms @ _, mut env @ _) => { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(&scrutinee, &env, &*fns) { + match crate::aver_generated::domain::eval::core::evalExpr( + scrutinee, + env.clone(), + &*fns, + ) { Ok(v @ _) => __MutualTco1::EvalMatch(v, arms, env), Err(e @ _) => return Err(e), } @@ -699,12 +703,21 @@ fn __mutual_tco_trampoline_1( mut env @ _, ) => { crate::cancel_checkpoint(); - let vecV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&vecExpr, &env, &*fns)?; - let idxV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&idxExpr, &env, &*fns)?; - let valueV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&valueExpr, &env, &*fns)?; + let vecV @ _ = crate::aver_generated::domain::eval::core::evalExpr( + vecExpr, + env.clone(), + &*fns, + )?; + let idxV @ _ = crate::aver_generated::domain::eval::core::evalExpr( + idxExpr, + env.clone(), + &*fns, + )?; + let valueV @ _ = crate::aver_generated::domain::eval::core::evalExpr( + valueExpr, + env.clone(), + &*fns, + )?; __MutualTco1::EvalVectorSetWithDefaultExprResult( vecV, idxV, @@ -789,10 +802,16 @@ fn __mutual_tco_trampoline_1( mut env @ _, ) => { crate::cancel_checkpoint(); - let vecV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&vecExpr, &env, &*fns)?; - let idxV @ _ = - crate::aver_generated::domain::eval::core::evalExpr(&idxExpr, &env, &*fns)?; + let vecV @ _ = crate::aver_generated::domain::eval::core::evalExpr( + vecExpr, + env.clone(), + &*fns, + )?; + let idxV @ _ = crate::aver_generated::domain::eval::core::evalExpr( + idxExpr, + env.clone(), + &*fns, + )?; __MutualTco1::EvalVectorGetWithDefaultExprResult(vecV, idxV, defaultExpr, env) } __MutualTco1::EvalVectorGetWithDefaultExprResult( @@ -822,175 +841,147 @@ fn __mutual_tco_trampoline_1( /// Evaluate an expression in the given environment. pub fn evalExpr( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1(__MutualTco1::EvalExpr(expr.clone(), env.clone()), &fns) + __mutual_tco_trampoline_1(__MutualTco1::EvalExpr(expr, env), &fns) } /// Continue named-env evaluation for branch, vars, and slot-only internal nodes. pub fn evalExprBasic( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1(__MutualTco1::EvalExprBasic(expr.clone(), env.clone()), &fns) + __mutual_tco_trampoline_1(__MutualTco1::EvalExprBasic(expr, env), &fns) } /// Continue named-env expression evaluation for comparisons and arithmetic. pub fn evalExprInternal( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalExprInternal(expr.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalExprInternal(expr, env), &fns) } /// Continue named-env evaluation for aggregate expression forms. pub fn evalExprAggregate( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalExprAggregate(expr.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalExprAggregate(expr, env), &fns) } /// Finish named-env evaluation for calls, matches, propagation, and products. pub fn evalExprCalls( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1(__MutualTco1::EvalExprCalls(expr.clone(), env.clone()), &fns) + __mutual_tco_trampoline_1(__MutualTco1::EvalExprCalls(expr, env), &fns) } /// Evaluate a direct bool branch in map path. pub fn evalBoolBranch( - cond @ _: &crate::aver_generated::domain::ast::Expr, - thenExpr @ _: &crate::aver_generated::domain::ast::Expr, - elseExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + cond @ _: crate::aver_generated::domain::ast::Expr, + thenExpr @ _: crate::aver_generated::domain::ast::Expr, + elseExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalBoolBranch( - cond.clone(), - thenExpr.clone(), - elseExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalBoolBranch(cond, thenExpr, elseExpr, env), &fns, ) } /// Evaluate a match expression. pub fn evalMatchExpr( - scrutinee @ _: &crate::aver_generated::domain::ast::Expr, - arms @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverMap, + scrutinee @ _: crate::aver_generated::domain::ast::Expr, + arms @ _: aver_rt::AverList, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalMatchExpr(scrutinee.clone(), arms.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalMatchExpr(scrutinee, arms, env), &fns) } /// Builtin dispatch by integer ID — no string comparison. pub fn evalCallBuiltinById( id @ _: aver_rt::AverInt, - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverMap, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalCallBuiltinById(id, argExprs.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalCallBuiltinById(id, argExprs, env), &fns) } /// Builtin dispatch with fast-path peepholes for hot patterns. pub fn evalCallBuiltinMaybeSpecial( name @ _: AverStr, - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverMap, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalCallBuiltinMaybeSpecial(name, argExprs.clone(), env.clone()), + __MutualTco1::EvalCallBuiltinMaybeSpecial(name, argExprs, env), &fns, ) } /// Specialize hot Option.withDefault(Vector.get/Vector.set, default) patterns in map path. pub fn evalOptionWithDefaultExpr( - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverMap, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalOptionWithDefaultExpr(argExprs.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalOptionWithDefaultExpr(argExprs, env), &fns) } /// Dispatch specialized Option.withDefault cases in map path. pub fn evalOptionWithDefaultExprInner( - optionExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + optionExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalOptionWithDefaultExprInner( - optionExpr.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalOptionWithDefaultExprInner(optionExpr, defaultExpr, env), &fns, ) } /// Specialized Vector.set + Option.withDefault in map path. pub fn evalVectorSetWithDefaultExpr( - vecArgs @ _: &aver_rt::AverList, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecArgs @ _: aver_rt::AverList, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalVectorSetWithDefaultExpr( - vecArgs.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalVectorSetWithDefaultExpr(vecArgs, defaultExpr, env), &fns, ) } /// Evaluate Vector.set operands in map path and defer the default expression until needed. pub fn evalVectorSetWithDefaultExprValues( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, - valueExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecExpr @ _: crate::aver_generated::domain::ast::Expr, + idxExpr @ _: crate::aver_generated::domain::ast::Expr, + valueExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( __MutualTco1::EvalVectorSetWithDefaultExprValues( - vecExpr.clone(), - idxExpr.clone(), - valueExpr.clone(), - defaultExpr.clone(), - env.clone(), + vecExpr, + idxExpr, + valueExpr, + defaultExpr, + env, ), &fns, ) @@ -998,91 +989,68 @@ pub fn evalVectorSetWithDefaultExprValues( /// Finish specialized Vector.set + Option.withDefault in map path with lazy default evaluation. pub fn evalVectorSetWithDefaultExprResult( - vecV @ _: &crate::aver_generated::domain::value::Val, - idxV @ _: &crate::aver_generated::domain::value::Val, - valueV @ _: &crate::aver_generated::domain::value::Val, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecV @ _: crate::aver_generated::domain::value::Val, + idxV @ _: crate::aver_generated::domain::value::Val, + valueV @ _: crate::aver_generated::domain::value::Val, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalVectorSetWithDefaultExprResult( - vecV.clone(), - idxV.clone(), - valueV.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalVectorSetWithDefaultExprResult(vecV, idxV, valueV, defaultExpr, env), &fns, ) } /// Specialized Vector.get + Option.withDefault in map path. pub fn evalVectorGetWithDefaultExpr( - vecArgs @ _: &aver_rt::AverList, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecArgs @ _: aver_rt::AverList, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalVectorGetWithDefaultExpr( - vecArgs.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalVectorGetWithDefaultExpr(vecArgs, defaultExpr, env), &fns, ) } /// Evaluate Vector.get operands in map path and defer the default expression until needed. pub fn evalVectorGetWithDefaultExprValues( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecExpr @ _: crate::aver_generated::domain::ast::Expr, + idxExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalVectorGetWithDefaultExprValues( - vecExpr.clone(), - idxExpr.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalVectorGetWithDefaultExprValues(vecExpr, idxExpr, defaultExpr, env), &fns, ) } /// Finish specialized Vector.get + Option.withDefault in map path with lazy default evaluation. pub fn evalVectorGetWithDefaultExprResult( - vecV @ _: &crate::aver_generated::domain::value::Val, - idxV @ _: &crate::aver_generated::domain::value::Val, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverMap, + vecV @ _: crate::aver_generated::domain::value::Val, + idxV @ _: crate::aver_generated::domain::value::Val, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_1( - __MutualTco1::EvalVectorGetWithDefaultExprResult( - vecV.clone(), - idxV.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco1::EvalVectorGetWithDefaultExprResult(vecV, idxV, defaultExpr, env), &fns, ) } /// Try each match arm until one matches. Self-recursive for codegen TCO. pub fn evalMatch( - v @ _: &crate::aver_generated::domain::value::Val, - arms @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverMap, + v @ _: crate::aver_generated::domain::value::Val, + arms @ _: aver_rt::AverList, + env @ _: aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_1( - __MutualTco1::EvalMatch(v.clone(), arms.clone(), env.clone()), - &fns, - ) + __mutual_tco_trampoline_1(__MutualTco1::EvalMatch(v, arms, env), &fns) } #[allow(non_camel_case_types)] @@ -1156,7 +1124,7 @@ fn __mutual_tco_trampoline_2( __MutualTco2::EvalTailMatchExprSlot(selfId, scrutinee, arms, slotCount, env) } _ => { - match crate::aver_generated::domain::eval::core::evalExprSlot(&expr, &env, &*slotMap, &*fns) { Ok(v @ _) => { return Ok(crate::aver_generated::domain::eval::core::SlotTailStep::SlotTailDone(v)) }, Err(e @ _) => { return Err(e) } } + match crate::aver_generated::domain::eval::core::evalExprSlot(expr, env, &*slotMap, &*fns) { Ok(v @ _) => { return Ok(crate::aver_generated::domain::eval::core::SlotTailStep::SlotTailDone(v)) }, Err(e @ _) => { return Err(e) } } } } } @@ -1170,7 +1138,10 @@ fn __mutual_tco_trampoline_2( ) => { crate::cancel_checkpoint(); let condV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &cond, &env, &*slotMap, &*fns, + cond, + env.clone(), + &*slotMap, + &*fns, )?; match condV.clone() { crate::aver_generated::domain::value::Val::ValBool(flag) => { @@ -1196,7 +1167,10 @@ fn __mutual_tco_trampoline_2( ) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &scrutinee, &env, &*slotMap, &*fns, + scrutinee, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco2::EvalTailMatchSlot(selfId, v, arms, slotCount, env) } @@ -1208,7 +1182,7 @@ fn __mutual_tco_trampoline_2( mut env @ _, ) => { crate::cancel_checkpoint(); - aver_list_match!(arms, [] => { return Err(AverStr::from("no matching arm")) }, [arm, rest] => match crate::aver_generated::domain::match_mod::matchPattern(&arm.pattern, &v) { Ok(bindings @ _) => { __MutualTco2::EvalTailExprSlot(selfId, arm.body.clone(), slotCount, crate::aver_generated::domain::eval::core::mergeBindingsSlot(&bindings, &arm.bindingSlots, &env)) }, Err(_) => { __MutualTco2::EvalTailMatchSlot(selfId, v, rest, slotCount, env) } }) + aver_list_match!(arms, [] => { return Err(AverStr::from("no matching arm")) }, [arm, rest] => match crate::aver_generated::domain::match_mod::matchPattern(&arm.pattern, &v) { Ok(bindings @ _) => { __MutualTco2::EvalTailExprSlot(selfId, arm.body.clone(), slotCount, crate::aver_generated::domain::eval::core::mergeBindingsSlot(bindings, &arm.bindingSlots, env)) }, Err(_) => { __MutualTco2::EvalTailMatchSlot(selfId, v, rest, slotCount, env) } }) } }; } @@ -1217,14 +1191,14 @@ fn __mutual_tco_trampoline_2( /// Evaluate a tail-position expression in slot mode, converting self-recursive direct calls into loop re-entry. pub fn evalTailExprSlot( selfId @ _: aver_rt::AverInt, - expr @ _: &crate::aver_generated::domain::ast::Expr, + expr @ _: crate::aver_generated::domain::ast::Expr, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_2( - __MutualTco2::EvalTailExprSlot(selfId, expr.clone(), slotCount, env.clone()), + __MutualTco2::EvalTailExprSlot(selfId, expr, slotCount, env), &slotMap, &fns, ) @@ -1233,23 +1207,16 @@ pub fn evalTailExprSlot( /// Evaluate a tail-position bool branch in slot mode. pub fn evalTailBoolBranchSlot( selfId @ _: aver_rt::AverInt, - cond @ _: &crate::aver_generated::domain::ast::Expr, - thenExpr @ _: &crate::aver_generated::domain::ast::Expr, - elseExpr @ _: &crate::aver_generated::domain::ast::Expr, + cond @ _: crate::aver_generated::domain::ast::Expr, + thenExpr @ _: crate::aver_generated::domain::ast::Expr, + elseExpr @ _: crate::aver_generated::domain::ast::Expr, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_2( - __MutualTco2::EvalTailBoolBranchSlot( - selfId, - cond.clone(), - thenExpr.clone(), - elseExpr.clone(), - slotCount, - env.clone(), - ), + __MutualTco2::EvalTailBoolBranchSlot(selfId, cond, thenExpr, elseExpr, slotCount, env), &slotMap, &fns, ) @@ -1258,21 +1225,15 @@ pub fn evalTailBoolBranchSlot( /// Evaluate a tail-position match expression in slot mode. pub fn evalTailMatchExprSlot( selfId @ _: aver_rt::AverInt, - scrutinee @ _: &crate::aver_generated::domain::ast::Expr, - arms @ _: &aver_rt::AverList, + scrutinee @ _: crate::aver_generated::domain::ast::Expr, + arms @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_2( - __MutualTco2::EvalTailMatchExprSlot( - selfId, - scrutinee.clone(), - arms.clone(), - slotCount, - env.clone(), - ), + __MutualTco2::EvalTailMatchExprSlot(selfId, scrutinee, arms, slotCount, env), &slotMap, &fns, ) @@ -1281,15 +1242,15 @@ pub fn evalTailMatchExprSlot( /// Evaluate a tail-position match arm in slot mode, preserving binding slots. pub fn evalTailMatchSlot( selfId @ _: aver_rt::AverInt, - v @ _: &crate::aver_generated::domain::value::Val, - arms @ _: &aver_rt::AverList, + v @ _: crate::aver_generated::domain::value::Val, + arms @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_2( - __MutualTco2::EvalTailMatchSlot(selfId, v.clone(), arms.clone(), slotCount, env.clone()), + __MutualTco2::EvalTailMatchSlot(selfId, v, arms, slotCount, env), &slotMap, &fns, ) @@ -1454,7 +1415,7 @@ fn __mutual_tco_trampoline_3( ) => { let vecExpr = (*vecExpr).clone(); let idxExpr = (*idxExpr).clone(); - return crate::aver_generated::domain::eval::core::evalVectorGetOrIntExprSlot(&vecExpr, &idxExpr, defaultValue, &env, &*slotMap, &*fns); + return crate::aver_generated::domain::eval::core::evalVectorGetOrIntExprSlot(vecExpr, idxExpr, defaultValue, &env, &*slotMap, &*fns); } crate::aver_generated::domain::ast::Expr::ExprIntModOrInt( a, @@ -1464,8 +1425,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalIntModOrIntExprSlot( - &a, - &b, + a, + b, defaultValue, &env, &*slotMap, @@ -1476,8 +1437,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinopSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1488,8 +1449,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinopSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1500,8 +1461,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinopSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1512,8 +1473,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalBinopSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1523,15 +1484,15 @@ fn __mutual_tco_trampoline_3( crate::aver_generated::domain::ast::Expr::ExprNeg(inner) => { let inner = (*inner).clone(); return crate::aver_generated::domain::eval::core::evalNegSlot( - &inner, &env, &*slotMap, &*fns, + inner, &env, &*slotMap, &*fns, ); } crate::aver_generated::domain::ast::Expr::ExprEq(a, b) => { let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1542,8 +1503,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1560,8 +1521,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1572,8 +1533,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1584,8 +1545,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1596,8 +1557,8 @@ fn __mutual_tco_trampoline_3( let a = (*a).clone(); let b = (*b).clone(); return crate::aver_generated::domain::eval::core::evalCmpSlot( - &a, - &b, + a, + b, &env, &*slotMap, &*fns, @@ -1640,7 +1601,7 @@ fn __mutual_tco_trampoline_3( crate::aver_generated::domain::ast::Expr::ExprFieldAccess(obj, field) => { let obj = (*obj).clone(); return crate::aver_generated::domain::eval::core::evalFieldAccessSlot( - &obj, field, &env, &*slotMap, &*fns, + obj, field, &env, &*slotMap, &*fns, ); } crate::aver_generated::domain::ast::Expr::ExprCall(name, argExprs) => { @@ -1673,7 +1634,7 @@ fn __mutual_tco_trampoline_3( }, crate::aver_generated::domain::ast::Expr::ExprPropagate(inner) => { let inner = (*inner).clone(); - return crate::aver_generated::domain::eval::core::evalPropagateSlot(&inner, &env, &*slotMap, &*fns) + return crate::aver_generated::domain::eval::core::evalPropagateSlot(inner, &env, &*slotMap, &*fns) }, crate::aver_generated::domain::ast::Expr::ExprIndependentProduct(exprs, unwrap) => { return crate::aver_generated::domain::eval::core::evalIndependentProductSlot(&exprs, unwrap, &env, &*slotMap, &*fns) @@ -1691,7 +1652,10 @@ fn __mutual_tco_trampoline_3( ) => { crate::cancel_checkpoint(); let condV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &cond, &env, &*slotMap, &*fns, + cond, + env.clone(), + &*slotMap, + &*fns, )?; match condV.clone() { crate::aver_generated::domain::value::Val::ValBool(flag) => { @@ -1868,13 +1832,22 @@ fn __mutual_tco_trampoline_3( ) => { crate::cancel_checkpoint(); let vecV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &vecExpr, &env, &*slotMap, &*fns, + vecExpr, + env.clone(), + &*slotMap, + &*fns, )?; let idxV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &idxExpr, &env, &*slotMap, &*fns, + idxExpr, + env.clone(), + &*slotMap, + &*fns, )?; let valueV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &valueExpr, &env, &*slotMap, &*fns, + valueExpr, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco3::EvalVectorSetWithDefaultExprSlotResult( vecV, @@ -1951,10 +1924,16 @@ fn __mutual_tco_trampoline_3( ) => { crate::cancel_checkpoint(); let vecV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &vecExpr, &env, &*slotMap, &*fns, + vecExpr, + env.clone(), + &*slotMap, + &*fns, )?; let idxV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &idxExpr, &env, &*slotMap, &*fns, + idxExpr, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco3::EvalVectorGetWithDefaultExprSlotResult(vecV, idxV, defaultExpr, env) } @@ -1978,13 +1957,16 @@ fn __mutual_tco_trampoline_3( __MutualTco3::EvalMatchExprSlot(mut scrutinee @ _, mut arms @ _, mut env @ _) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &scrutinee, &env, &*slotMap, &*fns, + scrutinee, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco3::EvalMatchSlot(v, arms, env) } __MutualTco3::EvalMatchSlot(mut v @ _, mut arms @ _, mut env @ _) => { crate::cancel_checkpoint(); - aver_list_match!(arms, [] => { return Err(AverStr::from("no matching arm")) }, [arm, rest] => match crate::aver_generated::domain::match_mod::matchPattern(&arm.pattern, &v) { Ok(bindings @ _) => { __MutualTco3::EvalExprSlot(arm.body.clone(), crate::aver_generated::domain::eval::core::mergeBindingsSlot(&bindings, &arm.bindingSlots, &env)) }, Err(_) => { __MutualTco3::EvalMatchSlot(v, rest, env) } }) + aver_list_match!(arms, [] => { return Err(AverStr::from("no matching arm")) }, [arm, rest] => match crate::aver_generated::domain::match_mod::matchPattern(&arm.pattern, &v) { Ok(bindings @ _) => { __MutualTco3::EvalExprSlot(arm.body.clone(), crate::aver_generated::domain::eval::core::mergeBindingsSlot(bindings, &arm.bindingSlots, env)) }, Err(_) => { __MutualTco3::EvalMatchSlot(v, rest, env) } }) } }; } @@ -1992,41 +1974,33 @@ fn __mutual_tco_trampoline_3( /// Evaluate an expression using slot-based environment. pub fn evalExprSlot( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::EvalExprSlot(expr.clone(), env.clone()), - &slotMap, - &fns, - ) + __mutual_tco_trampoline_3(__MutualTco3::EvalExprSlot(expr, env), &slotMap, &fns) } /// Continue slot-based evaluation for branches, vars, and slot-only nodes. pub fn evalExprSlotBasic( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::EvalExprSlotBasic(expr.clone(), env.clone()), - &slotMap, - &fns, - ) + __mutual_tco_trampoline_3(__MutualTco3::EvalExprSlotBasic(expr, env), &slotMap, &fns) } /// Continue slot-based expression evaluation for comparisons and arithmetic. pub fn evalExprSlotInternal( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalExprSlotInternal(expr.clone(), env.clone()), + __MutualTco3::EvalExprSlotInternal(expr, env), &slotMap, &fns, ) @@ -2034,13 +2008,13 @@ pub fn evalExprSlotInternal( /// Continue slot-based evaluation for aggregate and call expression forms. pub fn evalExprSlotAggregate( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalExprSlotAggregate(expr.clone(), env.clone()), + __MutualTco3::EvalExprSlotAggregate(expr, env), &slotMap, &fns, ) @@ -2048,34 +2022,25 @@ pub fn evalExprSlotAggregate( /// Finish slot-based evaluation for calls, matches, propagation, and products. pub fn evalExprSlotCalls( - expr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + expr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::EvalExprSlotCalls(expr.clone(), env.clone()), - &slotMap, - &fns, - ) + __mutual_tco_trampoline_3(__MutualTco3::EvalExprSlotCalls(expr, env), &slotMap, &fns) } /// Evaluate a direct bool branch in slot path. pub fn evalBoolBranchSlot( - cond @ _: &crate::aver_generated::domain::ast::Expr, - thenExpr @ _: &crate::aver_generated::domain::ast::Expr, - elseExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + cond @ _: crate::aver_generated::domain::ast::Expr, + thenExpr @ _: crate::aver_generated::domain::ast::Expr, + elseExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalBoolBranchSlot( - cond.clone(), - thenExpr.clone(), - elseExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalBoolBranchSlot(cond, thenExpr, elseExpr, env), &slotMap, &fns, ) @@ -2084,13 +2049,13 @@ pub fn evalBoolBranchSlot( /// Builtin dispatch by integer ID (slot-based path) — no string comparison. pub fn evalCallBuiltinByIdSlot( id @ _: aver_rt::AverInt, - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalCallBuiltinByIdSlot(id, argExprs.clone(), env.clone()), + __MutualTco3::EvalCallBuiltinByIdSlot(id, argExprs, env), &slotMap, &fns, ) @@ -2099,13 +2064,13 @@ pub fn evalCallBuiltinByIdSlot( /// Builtin dispatch with fast-path peepholes for hot patterns in slot path. pub fn evalCallBuiltinSlotMaybeSpecial( name @ _: AverStr, - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalCallBuiltinSlotMaybeSpecial(name, argExprs.clone(), env.clone()), + __MutualTco3::EvalCallBuiltinSlotMaybeSpecial(name, argExprs, env), &slotMap, &fns, ) @@ -2113,13 +2078,13 @@ pub fn evalCallBuiltinSlotMaybeSpecial( /// Specialize hot Option.withDefault(Vector.get/Vector.set, default) patterns in slot path. pub fn evalOptionWithDefaultExprSlot( - argExprs @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + argExprs @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalOptionWithDefaultExprSlot(argExprs.clone(), env.clone()), + __MutualTco3::EvalOptionWithDefaultExprSlot(argExprs, env), &slotMap, &fns, ) @@ -2127,18 +2092,14 @@ pub fn evalOptionWithDefaultExprSlot( /// Dispatch specialized Option.withDefault cases in slot path. pub fn evalOptionWithDefaultExprSlotInner( - optionExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + optionExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalOptionWithDefaultExprSlotInner( - optionExpr.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalOptionWithDefaultExprSlotInner(optionExpr, defaultExpr, env), &slotMap, &fns, ) @@ -2146,18 +2107,14 @@ pub fn evalOptionWithDefaultExprSlotInner( /// Specialized Vector.set + Option.withDefault in slot path. pub fn evalVectorSetWithDefaultExprSlot( - vecArgs @ _: &aver_rt::AverList, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecArgs @ _: aver_rt::AverList, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalVectorSetWithDefaultExprSlot( - vecArgs.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalVectorSetWithDefaultExprSlot(vecArgs, defaultExpr, env), &slotMap, &fns, ) @@ -2165,21 +2122,21 @@ pub fn evalVectorSetWithDefaultExprSlot( /// Evaluate Vector.set operands in slot path and defer the default expression until needed. pub fn evalVectorSetWithDefaultExprSlotValues( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, - valueExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecExpr @ _: crate::aver_generated::domain::ast::Expr, + idxExpr @ _: crate::aver_generated::domain::ast::Expr, + valueExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( __MutualTco3::EvalVectorSetWithDefaultExprSlotValues( - vecExpr.clone(), - idxExpr.clone(), - valueExpr.clone(), - defaultExpr.clone(), - env.clone(), + vecExpr, + idxExpr, + valueExpr, + defaultExpr, + env, ), &slotMap, &fns, @@ -2188,22 +2145,16 @@ pub fn evalVectorSetWithDefaultExprSlotValues( /// Finish specialized Vector.set + Option.withDefault in slot path with lazy default evaluation. pub fn evalVectorSetWithDefaultExprSlotResult( - vecV @ _: &crate::aver_generated::domain::value::Val, - idxV @ _: &crate::aver_generated::domain::value::Val, - valueV @ _: &crate::aver_generated::domain::value::Val, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecV @ _: crate::aver_generated::domain::value::Val, + idxV @ _: crate::aver_generated::domain::value::Val, + valueV @ _: crate::aver_generated::domain::value::Val, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalVectorSetWithDefaultExprSlotResult( - vecV.clone(), - idxV.clone(), - valueV.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalVectorSetWithDefaultExprSlotResult(vecV, idxV, valueV, defaultExpr, env), &slotMap, &fns, ) @@ -2211,18 +2162,14 @@ pub fn evalVectorSetWithDefaultExprSlotResult( /// Specialized Vector.get + Option.withDefault in slot path. pub fn evalVectorGetWithDefaultExprSlot( - vecArgs @ _: &aver_rt::AverList, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecArgs @ _: aver_rt::AverList, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalVectorGetWithDefaultExprSlot( - vecArgs.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalVectorGetWithDefaultExprSlot(vecArgs, defaultExpr, env), &slotMap, &fns, ) @@ -2230,20 +2177,15 @@ pub fn evalVectorGetWithDefaultExprSlot( /// Evaluate Vector.get operands in slot path and defer the default expression until needed. pub fn evalVectorGetWithDefaultExprSlotValues( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecExpr @ _: crate::aver_generated::domain::ast::Expr, + idxExpr @ _: crate::aver_generated::domain::ast::Expr, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalVectorGetWithDefaultExprSlotValues( - vecExpr.clone(), - idxExpr.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalVectorGetWithDefaultExprSlotValues(vecExpr, idxExpr, defaultExpr, env), &slotMap, &fns, ) @@ -2251,20 +2193,15 @@ pub fn evalVectorGetWithDefaultExprSlotValues( /// Finish specialized Vector.get + Option.withDefault in slot path with lazy default evaluation. pub fn evalVectorGetWithDefaultExprSlotResult( - vecV @ _: &crate::aver_generated::domain::value::Val, - idxV @ _: &crate::aver_generated::domain::value::Val, - defaultExpr @ _: &crate::aver_generated::domain::ast::Expr, - env @ _: &aver_rt::AverVector, + vecV @ _: crate::aver_generated::domain::value::Val, + idxV @ _: crate::aver_generated::domain::value::Val, + defaultExpr @ _: crate::aver_generated::domain::ast::Expr, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalVectorGetWithDefaultExprSlotResult( - vecV.clone(), - idxV.clone(), - defaultExpr.clone(), - env.clone(), - ), + __MutualTco3::EvalVectorGetWithDefaultExprSlotResult(vecV, idxV, defaultExpr, env), &slotMap, &fns, ) @@ -2272,14 +2209,14 @@ pub fn evalVectorGetWithDefaultExprSlotResult( /// Match expression in slot path. pub fn evalMatchExprSlot( - scrutinee @ _: &crate::aver_generated::domain::ast::Expr, - arms @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + scrutinee @ _: crate::aver_generated::domain::ast::Expr, + arms @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::EvalMatchExprSlot(scrutinee.clone(), arms.clone(), env.clone()), + __MutualTco3::EvalMatchExprSlot(scrutinee, arms, env), &slotMap, &fns, ) @@ -2287,17 +2224,13 @@ pub fn evalMatchExprSlot( /// Try each match arm in slot path. pub fn evalMatchSlot( - v @ _: &crate::aver_generated::domain::value::Val, - arms @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + v @ _: crate::aver_generated::domain::value::Val, + arms @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::EvalMatchSlot(v.clone(), arms.clone(), env.clone()), - &slotMap, - &fns, - ) + __mutual_tco_trampoline_3(__MutualTco3::EvalMatchSlot(v, arms, env), &slotMap, &fns) } #[allow(non_camel_case_types)] @@ -2324,7 +2257,7 @@ fn __mutual_tco_trampoline_4( __state = match __state { __MutualTco4::EvalArgsMapToNamedEnv(mut exprs @ _, mut params @ _, mut acc @ _) => { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc) }, [e, restExprs] => { match crate::aver_generated::domain::eval::core::evalExpr(&e, &*env, &*fns) { Err(err @ _) => { return Err(err) }, Ok(v @ _) => { __MutualTco4::EvalArgsMapToNamedEnvBind(restExprs, params, acc, v) } } }) + aver_list_match!(exprs, [] => { return Ok(acc) }, [e, restExprs] => { match crate::aver_generated::domain::eval::core::evalExpr(e, (*env).clone(), &*fns) { Err(err @ _) => { return Err(err) }, Ok(v @ _) => { __MutualTco4::EvalArgsMapToNamedEnvBind(restExprs, params, acc, v) } } }) } __MutualTco4::EvalArgsMapToNamedEnvBind( mut restExprs @ _, @@ -2341,14 +2274,14 @@ fn __mutual_tco_trampoline_4( /// Evaluate arg expressions directly into a callee named env from map caller state. pub fn evalArgsMapToNamedEnv( - exprs @ _: &aver_rt::AverList, - params @ _: &aver_rt::AverList, + exprs @ _: aver_rt::AverList, + params @ _: aver_rt::AverList, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, - acc @ _: &aver_rt::AverMap, + acc @ _: aver_rt::AverMap, ) -> Result, AverStr> { __mutual_tco_trampoline_4( - __MutualTco4::EvalArgsMapToNamedEnv(exprs.clone(), params.clone(), acc.clone()), + __MutualTco4::EvalArgsMapToNamedEnv(exprs, params, acc), &env, &fns, ) @@ -2356,20 +2289,15 @@ pub fn evalArgsMapToNamedEnv( /// Bind one evaluated arg into the callee named env when a parameter exists. pub fn evalArgsMapToNamedEnvBind( - restExprs @ _: &aver_rt::AverList, - params @ _: &aver_rt::AverList, + restExprs @ _: aver_rt::AverList, + params @ _: aver_rt::AverList, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, - acc @ _: &aver_rt::AverMap, - v @ _: &crate::aver_generated::domain::value::Val, + acc @ _: aver_rt::AverMap, + v @ _: crate::aver_generated::domain::value::Val, ) -> Result, AverStr> { __mutual_tco_trampoline_4( - __MutualTco4::EvalArgsMapToNamedEnvBind( - restExprs.clone(), - params.clone(), - acc.clone(), - v.clone(), - ), + __MutualTco4::EvalArgsMapToNamedEnvBind(restExprs, params, acc, v), &env, &fns, ) @@ -2400,7 +2328,7 @@ fn __mutual_tco_trampoline_5( __state = match __state { __MutualTco5::EvalArgsSlotToNamedEnv(mut exprs @ _, mut params @ _, mut acc @ _) => { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc) }, [e, restExprs] => { match crate::aver_generated::domain::eval::core::evalExprSlot(&e, &*env, &*slotMap, &*fns) { Err(err @ _) => { return Err(err) }, Ok(v @ _) => { __MutualTco5::EvalArgsSlotToNamedEnvBind(restExprs, params, acc, v) } } }) + aver_list_match!(exprs, [] => { return Ok(acc) }, [e, restExprs] => { match crate::aver_generated::domain::eval::core::evalExprSlot(e, (*env).clone(), &*slotMap, &*fns) { Err(err @ _) => { return Err(err) }, Ok(v @ _) => { __MutualTco5::EvalArgsSlotToNamedEnvBind(restExprs, params, acc, v) } } }) } __MutualTco5::EvalArgsSlotToNamedEnvBind( mut restExprs @ _, @@ -2417,15 +2345,15 @@ fn __mutual_tco_trampoline_5( /// Evaluate arg expressions directly into a callee named env from slot caller state. pub fn evalArgsSlotToNamedEnv( - exprs @ _: &aver_rt::AverList, - params @ _: &aver_rt::AverList, + exprs @ _: aver_rt::AverList, + params @ _: aver_rt::AverList, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, - acc @ _: &aver_rt::AverMap, + acc @ _: aver_rt::AverMap, ) -> Result, AverStr> { __mutual_tco_trampoline_5( - __MutualTco5::EvalArgsSlotToNamedEnv(exprs.clone(), params.clone(), acc.clone()), + __MutualTco5::EvalArgsSlotToNamedEnv(exprs, params, acc), &env, &slotMap, &fns, @@ -2434,21 +2362,16 @@ pub fn evalArgsSlotToNamedEnv( /// Bind one evaluated arg into the callee named env when a parameter exists. pub fn evalArgsSlotToNamedEnvBind( - restExprs @ _: &aver_rt::AverList, - params @ _: &aver_rt::AverList, + restExprs @ _: aver_rt::AverList, + params @ _: aver_rt::AverList, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, - acc @ _: &aver_rt::AverMap, - v @ _: &crate::aver_generated::domain::value::Val, + acc @ _: aver_rt::AverMap, + v @ _: crate::aver_generated::domain::value::Val, ) -> Result, AverStr> { __mutual_tco_trampoline_5( - __MutualTco5::EvalArgsSlotToNamedEnvBind( - restExprs.clone(), - params.clone(), - acc.clone(), - v.clone(), - ), + __MutualTco5::EvalArgsSlotToNamedEnvBind(restExprs, params, acc, v), &env, &slotMap, &fns, @@ -2500,12 +2423,12 @@ fn __mutual_tco_trampoline_6( /// Merge pattern bindings into slot env using the slots assigned for this specific arm. pub fn mergeBindingsSlot( - bindings @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, + bindings @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, bindingSlots @ _: &aver_rt::AverMap, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, ) -> aver_rt::AverVector { __mutual_tco_trampoline_6( - __MutualTco6::MergeBindingsSlot(bindings.clone(), env.clone()), + __MutualTco6::MergeBindingsSlot(bindings, env), &bindingSlots, ) } @@ -2513,13 +2436,13 @@ pub fn mergeBindingsSlot( /// Merge one pattern binding into slot env. pub fn mergeOneBindingSlot( name @ _: AverStr, - val @ _: &crate::aver_generated::domain::value::Val, - rest @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, + val @ _: crate::aver_generated::domain::value::Val, + rest @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, bindingSlots @ _: &aver_rt::AverMap, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, ) -> aver_rt::AverVector { __mutual_tco_trampoline_6( - __MutualTco6::MergeOneBindingSlot(name, val.clone(), rest.clone(), env.clone()), + __MutualTco6::MergeOneBindingSlot(name, val, rest, env), &bindingSlots, ) } @@ -2564,7 +2487,10 @@ fn __mutual_tco_trampoline_7( ) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &e, &env, &*slotMap, &*fns, + e, + env.clone(), + &*slotMap, + &*fns, )?; let nextEnv @ _ = crate::aver_generated::domain::eval::slots::setSlot(&env, slot, &v); @@ -2580,7 +2506,10 @@ fn __mutual_tco_trampoline_7( __MutualTco7::EvalStmtExprSlotNext(mut e @ _, mut rest @ _, mut env @ _) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &e, &env, &*slotMap, &*fns, + e, + env.clone(), + &*slotMap, + &*fns, )?; { let __list_subject = rest.clone(); @@ -2599,7 +2528,10 @@ fn __mutual_tco_trampoline_7( ) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &e, &env, &*slotMap, &*fns, + e, + env.clone(), + &*slotMap, + &*fns, )?; { let __list_subject = rest.clone(); @@ -2631,14 +2563,14 @@ fn __mutual_tco_trampoline_7( /// Evaluate a slot binding and continue statement execution without packing a tuple. pub fn evalStmtBindSlotNext( slot @ _: aver_rt::AverInt, - e @ _: &crate::aver_generated::domain::ast::Expr, - rest @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + e @ _: crate::aver_generated::domain::ast::Expr, + rest @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_7( - __MutualTco7::EvalStmtBindSlotNext(slot, e.clone(), rest.clone(), env.clone()), + __MutualTco7::EvalStmtBindSlotNext(slot, e, rest, env), &slotMap, &fns, ) @@ -2646,14 +2578,14 @@ pub fn evalStmtBindSlotNext( /// Evaluate an expression statement and continue statement execution without packing a tuple. pub fn evalStmtExprSlotNext( - e @ _: &crate::aver_generated::domain::ast::Expr, - rest @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + e @ _: crate::aver_generated::domain::ast::Expr, + rest @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_7( - __MutualTco7::EvalStmtExprSlotNext(e.clone(), rest.clone(), env.clone()), + __MutualTco7::EvalStmtExprSlotNext(e, rest, env), &slotMap, &fns, ) @@ -2662,14 +2594,14 @@ pub fn evalStmtExprSlotNext( /// Fallback for unresolved StmtBind in slot path without packing a tuple. pub fn evalStmtBindFallbackSlotNext( name @ _: AverStr, - e @ _: &crate::aver_generated::domain::ast::Expr, - rest @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + e @ _: crate::aver_generated::domain::ast::Expr, + rest @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_7( - __MutualTco7::EvalStmtBindFallbackSlotNext(name, e.clone(), rest.clone(), env.clone()), + __MutualTco7::EvalStmtBindFallbackSlotNext(name, e, rest, env), &slotMap, &fns, ) @@ -2677,16 +2609,12 @@ pub fn evalStmtBindFallbackSlotNext( /// Evaluate statements in slot path, threading env. pub fn evalStmtsSlot( - stmts @ _: &aver_rt::AverList, - env @ _: &aver_rt::AverVector, + stmts @ _: aver_rt::AverList, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { - __mutual_tco_trampoline_7( - __MutualTco7::EvalStmtsSlot(stmts.clone(), env.clone()), - &slotMap, - &fns, - ) + __mutual_tco_trampoline_7(__MutualTco7::EvalStmtsSlot(stmts, env), &slotMap, &fns) } #[allow(non_camel_case_types)] @@ -2767,7 +2695,10 @@ fn __mutual_tco_trampoline_8( ) => { crate::cancel_checkpoint(); let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( - &e, &env, &*slotMap, &*fns, + e, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco8::EvalStmtsSlotTail( selfId, @@ -2785,7 +2716,10 @@ fn __mutual_tco_trampoline_8( ) => { crate::cancel_checkpoint(); crate::aver_generated::domain::eval::core::evalExprSlot( - &e, &env, &*slotMap, &*fns, + e, + env.clone(), + &*slotMap, + &*fns, )?; __MutualTco8::EvalStmtsSlotTail(selfId, rest, slotCount, env) } @@ -2796,14 +2730,14 @@ fn __mutual_tco_trampoline_8( /// Evaluate slot statements when the final expression may self-tail-recur. pub fn evalStmtsSlotTail( selfId @ _: aver_rt::AverInt, - stmts @ _: &aver_rt::AverList, + stmts @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_8( - __MutualTco8::EvalStmtsSlotTail(selfId, stmts.clone(), slotCount, env.clone()), + __MutualTco8::EvalStmtsSlotTail(selfId, stmts, slotCount, env), &slotMap, &fns, ) @@ -2812,21 +2746,15 @@ pub fn evalStmtsSlotTail( /// Evaluate one non-final slot statement before continuing the tail-aware slot loop. pub fn evalStmtsSlotTailNext( selfId @ _: aver_rt::AverInt, - stmt @ _: &crate::aver_generated::domain::ast::Stmt, - rest @ _: &aver_rt::AverList, + stmt @ _: crate::aver_generated::domain::ast::Stmt, + rest @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_8( - __MutualTco8::EvalStmtsSlotTailNext( - selfId, - stmt.clone(), - rest.clone(), - slotCount, - env.clone(), - ), + __MutualTco8::EvalStmtsSlotTailNext(selfId, stmt, rest, slotCount, env), &slotMap, &fns, ) @@ -2836,22 +2764,15 @@ pub fn evalStmtsSlotTailNext( pub fn evalStmtsSlotTailBind( selfId @ _: aver_rt::AverInt, slot @ _: aver_rt::AverInt, - e @ _: &crate::aver_generated::domain::ast::Expr, - rest @ _: &aver_rt::AverList, + e @ _: crate::aver_generated::domain::ast::Expr, + rest @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_8( - __MutualTco8::EvalStmtsSlotTailBind( - selfId, - slot, - e.clone(), - rest.clone(), - slotCount, - env.clone(), - ), + __MutualTco8::EvalStmtsSlotTailBind(selfId, slot, e, rest, slotCount, env), &slotMap, &fns, ) @@ -2860,21 +2781,15 @@ pub fn evalStmtsSlotTailBind( /// Evaluate one non-final expression statement before continuing the tail-aware slot loop. pub fn evalStmtsSlotTailExpr( selfId @ _: aver_rt::AverInt, - e @ _: &crate::aver_generated::domain::ast::Expr, - rest @ _: &aver_rt::AverList, + e @ _: crate::aver_generated::domain::ast::Expr, + rest @ _: aver_rt::AverList, slotCount @ _: aver_rt::AverInt, - env @ _: &aver_rt::AverVector, + env @ _: aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { __mutual_tco_trampoline_8( - __MutualTco8::EvalStmtsSlotTailExpr( - selfId, - e.clone(), - rest.clone(), - slotCount, - env.clone(), - ), + __MutualTco8::EvalStmtsSlotTailExpr(selfId, e, rest, slotCount, env), &slotMap, &fns, ) @@ -3009,40 +2924,40 @@ pub fn evalVar( /// Evaluate a fused Vector.get + Option.withDefault in map path. pub fn evalVectorGetOrIntExpr( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, + mut vecExpr @ _: crate::aver_generated::domain::ast::Expr, + mut idxExpr @ _: crate::aver_generated::domain::ast::Expr, defaultValue @ _: aver_rt::AverInt, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let vecV @ _ = crate::aver_generated::domain::eval::core::evalExpr(vecExpr, env, fns)?; - let idxV @ _ = crate::aver_generated::domain::eval::core::evalExpr(idxExpr, env, fns)?; + let vecV @ _ = crate::aver_generated::domain::eval::core::evalExpr(vecExpr, env.clone(), fns)?; + let idxV @ _ = crate::aver_generated::domain::eval::core::evalExpr(idxExpr, env.clone(), fns)?; crate::aver_generated::domain::eval::ops::evalVectorGetOrIntVals(&vecV, &idxV, defaultValue) } /// Evaluate a fused Int.mod + Result.withDefault in map path. pub fn evalIntModOrIntExpr( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, defaultValue @ _: aver_rt::AverInt, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let aV @ _ = crate::aver_generated::domain::eval::core::evalExpr(a, env, fns)?; - let bV @ _ = crate::aver_generated::domain::eval::core::evalExpr(b, env, fns)?; + let aV @ _ = crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns)?; + let bV @ _ = crate::aver_generated::domain::eval::core::evalExpr(b, env.clone(), fns)?; crate::aver_generated::domain::eval::ops::evalIntModOrIntVals(&aV, &bV, defaultValue) } /// Evaluate ? operator: unwrap Ok or propagate Err. pub fn evalPropagate( - inner @ _: &crate::aver_generated::domain::ast::Expr, + mut inner @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(inner, env, fns)?; + let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(inner, env.clone(), fns)?; match v { crate::aver_generated::domain::value::Val::ValOk(x) => { let x = (*x).clone(); @@ -3092,7 +3007,7 @@ pub fn evalIndependentItems( fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [a, rest] => { aver_list_match!(rest, [] => match crate::aver_generated::domain::eval::core::evalExpr(&a, env, fns) { Ok(va @ _) => { Ok(aver_rt::AverList::from_vec(vec![va])) }, Err(e @ _) => { Err(e) } }, [b, rest2] => { { let __list_subject = rest2; if __list_subject.is_empty() { { let (va, vb) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalExpr(&a, env, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalExpr(&b, env, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let fns = fns; let a = a.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExpr(&a, env, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let fns = fns; let b = b.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExpr(&b, env, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(aver_rt::AverList::from_vec(vec![va, vb])) } } else { { let (leftExprs, rightExprs) = crate::aver_generated::domain::eval::core::splitIndependentExprs(exprs.clone(), aver_rt::AverList::empty(), aver_rt::AverList::empty(), true); { let (leftVals, rightVals) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalIndependentItems(&leftExprs, env, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalIndependentItems(&rightExprs, env, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let fns = fns; let leftExprs = leftExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItems(&leftExprs, env, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let fns = fns; let rightExprs = rightExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItems(&rightExprs, env, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(crate::aver_generated::domain::eval::core::interleaveIndependentVals(leftVals, rightVals, true, aver_rt::AverList::empty())) } } } } }) }) + aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [a, rest] => { aver_list_match!(rest, [] => match crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns) { Ok(va @ _) => { Ok(aver_rt::AverList::from_vec(vec![va])) }, Err(e @ _) => { Err(e) } }, [b, rest2] => { { let __list_subject = rest2; if __list_subject.is_empty() { { let (va, vb) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalExpr(b, env.clone(), fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let fns = fns; let a = a.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let fns = fns; let b = b.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExpr(b, env.clone(), fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(aver_rt::AverList::from_vec(vec![va, vb])) } } else { { let (leftExprs, rightExprs) = crate::aver_generated::domain::eval::core::splitIndependentExprs(exprs.clone(), aver_rt::AverList::empty(), aver_rt::AverList::empty(), true); { let (leftVals, rightVals) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalIndependentItems(&leftExprs, env, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalIndependentItems(&rightExprs, env, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let fns = fns; let leftExprs = leftExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItems(&leftExprs, env, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let fns = fns; let rightExprs = rightExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItems(&rightExprs, env, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(crate::aver_generated::domain::eval::core::interleaveIndependentVals(leftVals, rightVals, true, aver_rt::AverList::empty())) } } } } }) }) } /// Split a product into alternating branches so recursive ?! can cover all items. @@ -3220,13 +3135,13 @@ pub fn unwrapProductResults( /// Evaluate right side of binop and apply. pub fn evalBinopRight( va @ _: &crate::aver_generated::domain::value::Val, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::BinOp, ) -> Result { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(b, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(b, env.clone(), fns) { Err(e @ _) => Err(e), Ok(vb @ _) => crate::aver_generated::domain::eval::ops::evalBinopVals(va, &vb, op), } @@ -3234,14 +3149,14 @@ pub fn evalBinopRight( /// Evaluate a binary operation on two expressions. pub fn evalBinop( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::BinOp, ) -> Result { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(a, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns) { Err(e @ _) => Err(e), Ok(va @ _) => { crate::aver_generated::domain::eval::core::evalBinopRight(&va, b, env, fns, op) @@ -3251,12 +3166,12 @@ pub fn evalBinop( /// Evaluate unary minus on the named-env path. pub fn evalNeg( - inner @ _: &crate::aver_generated::domain::ast::Expr, + mut inner @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(inner, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(inner, env.clone(), fns) { Err(e @ _) => Err(e), Ok(v @ _) => crate::aver_generated::domain::eval::ops::evalNegVals(&v), } @@ -3265,13 +3180,13 @@ pub fn evalNeg( /// Evaluate right side of comparison and apply. pub fn evalCmpRight( va @ _: &crate::aver_generated::domain::value::Val, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::CmpOp, ) -> Result { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(b, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(b, env.clone(), fns) { Err(e @ _) => Err(e), Ok(vb @ _) => crate::aver_generated::domain::eval::ops::evalCmpVals(va, &vb, op), } @@ -3279,14 +3194,14 @@ pub fn evalCmpRight( /// Evaluate a comparison expression. pub fn evalCmp( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::CmpOp, ) -> Result { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(a, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(a, env.clone(), fns) { Err(e @ _) => Err(e), Ok(va @ _) => crate::aver_generated::domain::eval::core::evalCmpRight(&va, b, env, fns, op), } @@ -3318,7 +3233,7 @@ pub fn evalConcatParts( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(parts, [] => { return Ok(crate::aver_generated::domain::value::Val::ValStr(acc)); }, [p, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(&p, &*env, &*fns) { Err(e @ _) => { return Err(e); }, Ok(v @ _) => { { + aver_list_match!(parts, [] => { return Ok(crate::aver_generated::domain::value::Val::ValStr(acc)); }, [p, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(p, (*env).clone(), &*fns) { Err(e @ _) => { return Err(e); }, Ok(v @ _) => { { let __tco0 = rest; let __tco3 = (acc + &crate::aver_generated::domain::value::valRepr(&v)); parts = __tco0; @@ -3361,19 +3276,19 @@ pub fn evalRecordFields( fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - aver_list_match!(fieldExprs.clone(), [] => Ok(aver_rt::AverList::empty()), [pair, rest] => { { let (fname, expr) = pair; crate::aver_generated::domain::eval::core::evalRecordFieldOne(fname, &expr, &rest, env, fns) } }) + aver_list_match!(fieldExprs.clone(), [] => Ok(aver_rt::AverList::empty()), [pair, rest] => { { let (fname, expr) = pair; crate::aver_generated::domain::eval::core::evalRecordFieldOne(fname, expr, &rest, env, fns) } }) } /// Evaluate one record field and continue. pub fn evalRecordFieldOne( fname @ _: AverStr, - expr @ _: &crate::aver_generated::domain::ast::Expr, + mut expr @ _: crate::aver_generated::domain::ast::Expr, rest @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(expr, env, fns)?; + let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(expr, env.clone(), fns)?; let restFields @ _ = crate::aver_generated::domain::eval::core::evalRecordFields(rest, env, fns)?; Ok(aver_rt::AverList::prepend((fname, v), &restFields)) @@ -3381,13 +3296,13 @@ pub fn evalRecordFieldOne( /// Evaluate field access: obj.field. pub fn evalFieldAccess( - obj @ _: &crate::aver_generated::domain::ast::Expr, + mut obj @ _: crate::aver_generated::domain::ast::Expr, field @ _: AverStr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(obj, env, fns)?; + let v @ _ = crate::aver_generated::domain::eval::core::evalExpr(obj, env.clone(), fns)?; match v { crate::aver_generated::domain::value::Val::ValRecord(_, fields) => { crate::aver_generated::domain::eval::common::lookupField(fields, field) @@ -3435,7 +3350,7 @@ pub fn evalListItemsRev( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(&e, &*env, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(e, (*env).clone(), &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco3 = aver_rt::AverList::prepend(v, &acc); exprs = __tco0; @@ -3471,7 +3386,7 @@ pub fn evalArgsRev( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(&e, &*env, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(e, (*env).clone(), &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco3 = aver_rt::AverList::prepend(v, &acc); exprs = __tco0; @@ -3663,8 +3578,8 @@ pub fn evalResolvedSlotDirect( } crate::aver_generated::domain::ast::FnFastPath::FastNone => { crate::aver_generated::domain::eval::core::evalStmtsSlot( - &fd.body, - calleeEnv, + fd.body.clone(), + calleeEnv.clone(), &fd.slotMap, &fns, ) @@ -3788,9 +3703,9 @@ pub fn evalResolvedSlotStep( crate::aver_generated::domain::ast::FnFastPath::FastNone => { crate::aver_generated::domain::eval::core::evalStmtsSlotTail( fnId, - &fd.body, + fd.body.clone(), fd.slotCount.clone(), - calleeEnv, + calleeEnv.clone(), &fd.slotMap, &fns, ) @@ -3847,11 +3762,19 @@ pub fn evalResolvedSingleExprSlot( ) } else { crate::aver_generated::domain::eval::core::evalStmtsSlot( - body, calleeEnv, slotMap, fns, + body.clone(), + calleeEnv.clone(), + slotMap, + fns, ) } } else { - crate::aver_generated::domain::eval::core::evalStmtsSlot(body, calleeEnv, slotMap, fns) + crate::aver_generated::domain::eval::core::evalStmtsSlot( + body.clone(), + calleeEnv.clone(), + slotMap, + fns, + ) } } } @@ -3875,7 +3798,10 @@ pub fn evalResolvedSingleExprSlotTail( ) } else { match crate::aver_generated::domain::eval::core::evalStmtsSlot( - body, calleeEnv, slotMap, fns, + body.clone(), + calleeEnv.clone(), + slotMap, + fns, ) { Ok(v @ _) => Ok( crate::aver_generated::domain::eval::core::SlotTailStep::SlotTailDone(v), @@ -3885,7 +3811,10 @@ pub fn evalResolvedSingleExprSlotTail( } } else { match crate::aver_generated::domain::eval::core::evalStmtsSlot( - body, calleeEnv, slotMap, fns, + body.clone(), + calleeEnv.clone(), + slotMap, + fns, ) { Ok(v @ _) => { Ok(crate::aver_generated::domain::eval::core::SlotTailStep::SlotTailDone(v)) @@ -3909,13 +3838,18 @@ pub fn evalTailStmtSlot( match stmt.clone() { crate::aver_generated::domain::ast::Stmt::StmtExpr(expr) => { crate::aver_generated::domain::eval::core::evalTailExprSlot( - selfId, &expr, slotCount, env, slotMap, fns, + selfId, + expr, + slotCount, + env.clone(), + slotMap, + fns, ) } _ => { match crate::aver_generated::domain::eval::core::evalStmtsSlot( - &aver_rt::AverList::from_vec(vec![stmt.clone()]), - env, + aver_rt::AverList::from_vec(vec![stmt.clone()]), + env.clone(), slotMap, fns, ) { @@ -3938,11 +3872,16 @@ pub fn evalResolvedSingleStmtSlot( crate::cancel_checkpoint(); match stmt.clone() { crate::aver_generated::domain::ast::Stmt::StmtExpr(expr) => { - crate::aver_generated::domain::eval::core::evalExprSlot(&expr, calleeEnv, slotMap, fns) + crate::aver_generated::domain::eval::core::evalExprSlot( + expr, + calleeEnv.clone(), + slotMap, + fns, + ) } _ => crate::aver_generated::domain::eval::core::evalStmtsSlot( - &aver_rt::AverList::from_vec(vec![stmt.clone()]), - calleeEnv, + aver_rt::AverList::from_vec(vec![stmt.clone()]), + calleeEnv.clone(), slotMap, fns, ), @@ -3989,7 +3928,7 @@ pub fn evalResolvedSingleStmtNamed( crate::cancel_checkpoint(); match stmt.clone() { crate::aver_generated::domain::ast::Stmt::StmtExpr(expr) => { - crate::aver_generated::domain::eval::core::evalExpr(&expr, calleeEnv, &fns) + crate::aver_generated::domain::eval::core::evalExpr(expr, calleeEnv.clone(), &fns) } _ => crate::aver_generated::domain::eval::core::evalStmts( aver_rt::AverList::from_vec(vec![stmt.clone()]), @@ -4129,11 +4068,11 @@ pub fn evalCallDirectMapToNamed( ) -> Result { crate::cancel_checkpoint(); let calleeEnv @ _ = crate::aver_generated::domain::eval::core::evalArgsMapToNamedEnv( - argExprs, - &fd.params, + argExprs.clone(), + fd.params.clone(), env, &fns, - &HashMap::new(), + HashMap::new(), )?; crate::aver_generated::domain::eval::core::evalResolvedNamedFn(fd, &calleeEnv, fns) } @@ -4154,7 +4093,7 @@ pub fn evalCallBuiltin( /// Evaluate a statement expression. pub fn evalStmtExpr( - e @ _: &crate::aver_generated::domain::ast::Expr, + mut e @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result< @@ -4165,7 +4104,7 @@ pub fn evalStmtExpr( AverStr, > { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(e, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(e, env.clone(), fns) { Ok(v @ _) => Ok((v, env.clone())), Err(msg @ _) => Err(msg), } @@ -4174,7 +4113,7 @@ pub fn evalStmtExpr( /// Evaluate a binding statement. pub fn evalStmtBind( name @ _: AverStr, - e @ _: &crate::aver_generated::domain::ast::Expr, + mut e @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result< @@ -4185,7 +4124,7 @@ pub fn evalStmtBind( AverStr, > { crate::cancel_checkpoint(); - match crate::aver_generated::domain::eval::core::evalExpr(e, env, fns) { + match crate::aver_generated::domain::eval::core::evalExpr(e, env.clone(), fns) { Ok(v @ _) => Ok((v.clone(), env.clone().insert_owned(name, v))), Err(msg @ _) => Err(msg), } @@ -4206,13 +4145,13 @@ pub fn evalStmt( crate::cancel_checkpoint(); match stmt.clone() { crate::aver_generated::domain::ast::Stmt::StmtExpr(e) => { - crate::aver_generated::domain::eval::core::evalStmtExpr(&e, env, fns) + crate::aver_generated::domain::eval::core::evalStmtExpr(e, env, fns) } crate::aver_generated::domain::ast::Stmt::StmtBind(name, e) => { - crate::aver_generated::domain::eval::core::evalStmtBind(name, &e, env, fns) + crate::aver_generated::domain::eval::core::evalStmtBind(name, e, env, fns) } crate::aver_generated::domain::ast::Stmt::StmtBindSlot(_, e) => { - crate::aver_generated::domain::eval::core::evalStmtExpr(&e, env, fns) + crate::aver_generated::domain::eval::core::evalStmtExpr(e, env, fns) } } } @@ -4432,75 +4371,90 @@ pub fn evalCmpSlots( /// Evaluate a fused Vector.get + Option.withDefault in slot path. pub fn evalVectorGetOrIntExprSlot( - vecExpr @ _: &crate::aver_generated::domain::ast::Expr, - idxExpr @ _: &crate::aver_generated::domain::ast::Expr, + mut vecExpr @ _: crate::aver_generated::domain::ast::Expr, + mut idxExpr @ _: crate::aver_generated::domain::ast::Expr, defaultValue @ _: aver_rt::AverInt, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let vecV @ _ = - crate::aver_generated::domain::eval::core::evalExprSlot(vecExpr, env, slotMap, fns)?; - let idxV @ _ = - crate::aver_generated::domain::eval::core::evalExprSlot(idxExpr, env, slotMap, fns)?; + let vecV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( + vecExpr, + env.clone(), + slotMap, + fns, + )?; + let idxV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot( + idxExpr, + env.clone(), + slotMap, + fns, + )?; crate::aver_generated::domain::eval::ops::evalVectorGetOrIntVals(&vecV, &idxV, defaultValue) } /// Evaluate a fused Int.mod + Result.withDefault in slot path. pub fn evalIntModOrIntExprSlot( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, defaultValue @ _: aver_rt::AverInt, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let aV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(a, env, slotMap, fns)?; - let bV @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(b, env, slotMap, fns)?; + let aV @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns)?; + let bV @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(b, env.clone(), slotMap, fns)?; crate::aver_generated::domain::eval::ops::evalIntModOrIntVals(&aV, &bV, defaultValue) } /// Binary op in slot path. pub fn evalBinopSlot( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::BinOp, ) -> Result { crate::cancel_checkpoint(); - let va @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(a, env, slotMap, fns)?; - let vb @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(b, env, slotMap, fns)?; + let va @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns)?; + let vb @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(b, env.clone(), slotMap, fns)?; crate::aver_generated::domain::eval::ops::evalBinopVals(&va, &vb, op) } /// Unary minus in slot path. pub fn evalNegSlot( - inner @ _: &crate::aver_generated::domain::ast::Expr, + mut inner @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(inner, env, slotMap, fns)?; + let v @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(inner, env.clone(), slotMap, fns)?; crate::aver_generated::domain::eval::ops::evalNegVals(&v) } /// Comparison in slot path. pub fn evalCmpSlot( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + mut a @ _: crate::aver_generated::domain::ast::Expr, + mut b @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, op @ _: &crate::aver_generated::domain::ast::CmpOp, ) -> Result { crate::cancel_checkpoint(); - let va @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(a, env, slotMap, fns)?; - let vb @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(b, env, slotMap, fns)?; + let va @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns)?; + let vb @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(b, env.clone(), slotMap, fns)?; crate::aver_generated::domain::eval::ops::evalCmpVals(&va, &vb, op) } @@ -4534,7 +4488,7 @@ pub fn evalConcatPartsSlot( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(parts, [] => { return Ok(crate::aver_generated::domain::value::Val::ValStr(acc)); }, [p, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(&p, &*env, &*slotMap, &*fns) { Err(e @ _) => { return Err(e); }, Ok(v @ _) => { { + aver_list_match!(parts, [] => { return Ok(crate::aver_generated::domain::value::Val::ValStr(acc)); }, [p, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(p, (*env).clone(), &*slotMap, &*fns) { Err(e @ _) => { return Err(e); }, Ok(v @ _) => { { let __tco0 = rest; let __tco4 = (acc + &crate::aver_generated::domain::value::valRepr(&v)); parts = __tco0; @@ -4600,7 +4554,7 @@ pub fn evalListItemsSlotRev( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(&e, &*env, &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(e, (*env).clone(), &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco4 = aver_rt::AverList::prepend(v, &acc); exprs = __tco0; @@ -4635,20 +4589,21 @@ pub fn evalRecordFieldsSlot( fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - aver_list_match!(fieldExprs.clone(), [] => Ok(aver_rt::AverList::empty()), [pair, rest] => { { let (fname, expr) = pair; crate::aver_generated::domain::eval::core::evalRecordFieldOneSlot(fname, &expr, &rest, env, slotMap, fns) } }) + aver_list_match!(fieldExprs.clone(), [] => Ok(aver_rt::AverList::empty()), [pair, rest] => { { let (fname, expr) = pair; crate::aver_generated::domain::eval::core::evalRecordFieldOneSlot(fname, expr, &rest, env, slotMap, fns) } }) } /// Evaluate one record field in slot path. pub fn evalRecordFieldOneSlot( fname @ _: AverStr, - expr @ _: &crate::aver_generated::domain::ast::Expr, + mut expr @ _: crate::aver_generated::domain::ast::Expr, rest @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(expr, env, slotMap, fns)?; + let v @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(expr, env.clone(), slotMap, fns)?; let restFields @ _ = crate::aver_generated::domain::eval::core::evalRecordFieldsSlot(rest, env, slotMap, fns)?; Ok(aver_rt::AverList::prepend((fname, v), &restFields)) @@ -4656,14 +4611,15 @@ pub fn evalRecordFieldOneSlot( /// Field access in slot path. pub fn evalFieldAccessSlot( - obj @ _: &crate::aver_generated::domain::ast::Expr, + mut obj @ _: crate::aver_generated::domain::ast::Expr, field @ _: AverStr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(obj, env, slotMap, fns)?; + let v @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(obj, env.clone(), slotMap, fns)?; match v { crate::aver_generated::domain::value::Val::ValRecord(_, fields) => { crate::aver_generated::domain::eval::common::lookupField(fields, field) @@ -4748,12 +4704,12 @@ pub fn evalCallDirectSlotToNamed( ) -> Result { crate::cancel_checkpoint(); let calleeEnv @ _ = crate::aver_generated::domain::eval::core::evalArgsSlotToNamedEnv( - argExprs, - &fd.params, + argExprs.clone(), + fd.params.clone(), env, slotMap, &fns, - &HashMap::new(), + HashMap::new(), )?; crate::aver_generated::domain::eval::core::evalResolvedNamedFn(fd, &calleeEnv, fns) } @@ -4780,48 +4736,54 @@ pub fn evalArgsSlot( mut fns @ _: crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [e0, rest] => { aver_list_match!(rest, [] => crate::aver_generated::domain::eval::core::evalArgsSlot1(&e0, env, slotMap, &fns), [e1, rest2] => { aver_list_match!(rest2, [] => crate::aver_generated::domain::eval::core::evalArgsSlot2(&e0, &e1, env, slotMap, &fns), [e2, rest3] => { { let __list_subject = rest3; if __list_subject.is_empty() { crate::aver_generated::domain::eval::core::evalArgsSlot3(&e0, &e1, &e2, env, slotMap, &fns) } else { crate::aver_generated::domain::eval::core::evalArgsSlotRev(exprs.clone(), env.clone(), slotMap.clone(), fns, aver_rt::AverList::empty()) } } }) }) }) + aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [e0, rest] => { aver_list_match!(rest, [] => crate::aver_generated::domain::eval::core::evalArgsSlot1(e0, env, slotMap, &fns), [e1, rest2] => { aver_list_match!(rest2, [] => crate::aver_generated::domain::eval::core::evalArgsSlot2(e0, e1, env, slotMap, &fns), [e2, rest3] => { { let __list_subject = rest3; if __list_subject.is_empty() { crate::aver_generated::domain::eval::core::evalArgsSlot3(e0, e1, e2, env, slotMap, &fns) } else { crate::aver_generated::domain::eval::core::evalArgsSlotRev(exprs.clone(), env.clone(), slotMap.clone(), fns, aver_rt::AverList::empty()) } } }) }) }) } /// Fast path for one slot-path argument. pub fn evalArgsSlot1( - e0 @ _: &crate::aver_generated::domain::ast::Expr, + mut e0 @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - let v0 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e0, env, slotMap, fns)?; + let v0 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e0, env.clone(), slotMap, fns)?; Ok(aver_rt::AverList::from_vec(vec![v0])) } /// Fast path for two slot-path arguments. pub fn evalArgsSlot2( - e0 @ _: &crate::aver_generated::domain::ast::Expr, - e1 @ _: &crate::aver_generated::domain::ast::Expr, + mut e0 @ _: crate::aver_generated::domain::ast::Expr, + mut e1 @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - let v0 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e0, env, slotMap, fns)?; - let v1 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e1, env, slotMap, fns)?; + let v0 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e0, env.clone(), slotMap, fns)?; + let v1 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e1, env.clone(), slotMap, fns)?; Ok(aver_rt::AverList::from_vec(vec![v0, v1])) } /// Fast path for three slot-path arguments. pub fn evalArgsSlot3( - e0 @ _: &crate::aver_generated::domain::ast::Expr, - e1 @ _: &crate::aver_generated::domain::ast::Expr, - e2 @ _: &crate::aver_generated::domain::ast::Expr, + mut e0 @ _: crate::aver_generated::domain::ast::Expr, + mut e1 @ _: crate::aver_generated::domain::ast::Expr, + mut e2 @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - let v0 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e0, env, slotMap, fns)?; - let v1 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e1, env, slotMap, fns)?; - let v2 @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(e2, env, slotMap, fns)?; + let v0 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e0, env.clone(), slotMap, fns)?; + let v1 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e1, env.clone(), slotMap, fns)?; + let v2 @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(e2, env.clone(), slotMap, fns)?; Ok(aver_rt::AverList::from_vec(vec![v0, v1, v2])) } @@ -4838,7 +4800,7 @@ pub fn evalArgsSlotRev( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(&e, &*env, &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc.reverse()); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(e, (*env).clone(), &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco4 = aver_rt::AverList::prepend(v, &acc); exprs = __tco0; @@ -4860,7 +4822,7 @@ pub fn evalArgsMapToSlotEnv( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(&e, &*env, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExpr(e, (*env).clone(), &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco3 = crate::aver_generated::domain::eval::slots::setSlot(&acc, idx.clone(), &v); let __tco4 = idx.add(&aver_rt::AverInt::from_i64(1)); @@ -4886,7 +4848,7 @@ pub fn evalArgsSlotToSlotEnv( let fns @ _ = std::sync::Arc::new(fns); loop { crate::cancel_checkpoint(); - aver_list_match!(exprs, [] => { return Ok(acc); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(&e, &*env, &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { + aver_list_match!(exprs, [] => { return Ok(acc); }, [e, rest] => { match crate::aver_generated::domain::eval::core::evalExprSlot(e, (*env).clone(), &*slotMap, &*fns) { Err(err @ _) => { return Err(err); }, Ok(v @ _) => { { let __tco0 = rest; let __tco4 = crate::aver_generated::domain::eval::slots::setSlot(&acc, idx.clone(), &v); let __tco5 = idx.add(&aver_rt::AverInt::from_i64(1)); @@ -4900,13 +4862,14 @@ pub fn evalArgsSlotToSlotEnv( /// Evaluate ? operator in slot path. pub fn evalPropagateSlot( - inner @ _: &crate::aver_generated::domain::ast::Expr, + mut inner @ _: crate::aver_generated::domain::ast::Expr, env @ _: &aver_rt::AverVector, slotMap @ _: &aver_rt::AverMap, fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result { crate::cancel_checkpoint(); - let v @ _ = crate::aver_generated::domain::eval::core::evalExprSlot(inner, env, slotMap, fns)?; + let v @ _ = + crate::aver_generated::domain::eval::core::evalExprSlot(inner, env.clone(), slotMap, fns)?; match v { crate::aver_generated::domain::value::Val::ValOk(x) => { let x = (*x).clone(); @@ -4959,7 +4922,7 @@ pub fn evalIndependentItemsSlot( fns @ _: &crate::aver_generated::domain::eval::store::FnStore, ) -> Result, AverStr> { crate::cancel_checkpoint(); - aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [a, rest] => { aver_list_match!(rest, [] => match crate::aver_generated::domain::eval::core::evalExprSlot(&a, env, slotMap, fns) { Ok(va @ _) => { Ok(aver_rt::AverList::from_vec(vec![va])) }, Err(e @ _) => { Err(e) } }, [b, rest2] => { { let __list_subject = rest2; if __list_subject.is_empty() { { let (va, vb) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalExprSlot(&a, env, slotMap, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalExprSlot(&b, env, slotMap, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let slotMap = slotMap; let fns = fns; let a = a.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExprSlot(&a, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let slotMap = slotMap; let fns = fns; let b = b.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExprSlot(&b, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(aver_rt::AverList::from_vec(vec![va, vb])) } } else { { let (leftExprs, rightExprs) = crate::aver_generated::domain::eval::core::splitIndependentExprs(exprs.clone(), aver_rt::AverList::empty(), aver_rt::AverList::empty(), true); { let (leftVals, rightVals) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&leftExprs, env, slotMap, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&rightExprs, env, slotMap, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let slotMap = slotMap; let fns = fns; let leftExprs = leftExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&leftExprs, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let slotMap = slotMap; let fns = fns; let rightExprs = rightExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&rightExprs, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(crate::aver_generated::domain::eval::core::interleaveIndependentVals(leftVals, rightVals, true, aver_rt::AverList::empty())) } } } } }) }) + aver_list_match!(exprs.clone(), [] => Ok(aver_rt::AverList::empty()), [a, rest] => { aver_list_match!(rest, [] => match crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns) { Ok(va @ _) => { Ok(aver_rt::AverList::from_vec(vec![va])) }, Err(e @ _) => { Err(e) } }, [b, rest2] => { { let __list_subject = rest2; if __list_subject.is_empty() { { let (va, vb) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalExprSlot(b, env.clone(), slotMap, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let slotMap = slotMap; let fns = fns; let a = a.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExprSlot(a, env.clone(), slotMap, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let slotMap = slotMap; let fns = fns; let b = b.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalExprSlot(b, env.clone(), slotMap, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(aver_rt::AverList::from_vec(vec![va, vb])) } } else { { let (leftExprs, rightExprs) = crate::aver_generated::domain::eval::core::splitIndependentExprs(exprs.clone(), aver_rt::AverList::empty(), aver_rt::AverList::empty(), true); { let (leftVals, rightVals) = if crate::aver_replay::is_effect_tracking_active() { crate::aver_replay::enter_effect_group(); crate::aver_replay::set_effect_branch(0); let __r0 = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&leftExprs, env, slotMap, fns); crate::aver_replay::set_effect_branch(1); let __r1 = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&rightExprs, env, slotMap, fns); crate::aver_replay::exit_effect_group(); match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }? } else { { let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); std::thread::scope(|__s| { let __parallel_scope0 = __parallel_scope.clone(); let __cancel_flag0 = __cancel_flag.clone(); let __h0 = { let env = env; let slotMap = slotMap; let fns = fns; let leftExprs = leftExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope0.clone(), move || { crate::run_cancelable_branch(__cancel_flag0.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&leftExprs, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag0.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __parallel_scope1 = __parallel_scope.clone(); let __cancel_flag1 = __cancel_flag.clone(); let __h1 = { let env = env; let slotMap = slotMap; let fns = fns; let rightExprs = rightExprs.clone(); __s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope1.clone(), move || { crate::run_cancelable_branch(__cancel_flag1.clone(), move || { let __result = crate::aver_generated::domain::eval::core::evalIndependentItemsSlot(&rightExprs, env, slotMap, fns); if let Err(_) = &__result { __cancel_flag1.store(true, std::sync::atomic::Ordering::Relaxed); } __result }) })) }; let __b0 = __h0.join().unwrap(); let __b1 = __h1.join().unwrap(); match (__b0, __b1) { (crate::ParallelBranch::Completed(__r0), crate::ParallelBranch::Completed(__r1)) => match (__r0, __r1) { (Ok(__v0), Ok(__v1)) => Ok((__v0, __v1)), (__r0, __r1) => { if let Err(__err) = __r0 { Err(__err) } else if let Err(__err) = __r1 { Err(__err) } else { unreachable!("independent product unwrap requires Result branches") } } }, (__b0, __b1) => { if let crate::ParallelBranch::Completed(Err(__err)) = __b0 { Err(__err) } else if let crate::ParallelBranch::Completed(Err(__err)) = __b1 { Err(__err) } else { panic!("independent product branch cancelled by sibling branch") } } } })? }}; Ok(crate::aver_generated::domain::eval::core::interleaveIndependentVals(leftVals, rightVals, true, aver_rt::AverList::empty())) } } } } }) }) } /// Synthesized collecting variant of `unwrapProductResults`. Appends to a builder where `unwrapProductResults` prepends to `acc` and reverses on the way out, which reaches the same list without the cons chain or the reversal. Call sites that start the accumulator at `[]` are moved here. diff --git a/src/self_host/aver_generated/domain/match_mod/mod.rs b/src/self_host/aver_generated/domain/match_mod/mod.rs index 929f28180..06cac8761 100644 --- a/src/self_host/aver_generated/domain/match_mod/mod.rs +++ b/src/self_host/aver_generated/domain/match_mod/mod.rs @@ -48,31 +48,23 @@ fn __mutual_tco_trampoline_1( /// Accumulate bindings from tuple pattern matching. pub fn matchPatTupleItemsAcc( - pats @ _: &aver_rt::AverList, - items @ _: &aver_rt::AverList, - acc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, + pats @ _: aver_rt::AverList, + items @ _: aver_rt::AverList, + acc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, ) -> Result, AverStr> { - __mutual_tco_trampoline_1(__MutualTco1::MatchPatTupleItemsAcc( - pats.clone(), - items.clone(), - acc.clone(), - )) + __mutual_tco_trampoline_1(__MutualTco1::MatchPatTupleItemsAcc(pats, items, acc)) } /// Match one tuple element and continue with accumulated bindings. pub fn matchPatTupleOne( - pat @ _: &crate::aver_generated::domain::ast::Pattern, - item @ _: &crate::aver_generated::domain::value::Val, - restPats @ _: &aver_rt::AverList, - restItems @ _: &aver_rt::AverList, - acc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, + pat @ _: crate::aver_generated::domain::ast::Pattern, + item @ _: crate::aver_generated::domain::value::Val, + restPats @ _: aver_rt::AverList, + restItems @ _: aver_rt::AverList, + acc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::value::Val)>, ) -> Result, AverStr> { __mutual_tco_trampoline_1(__MutualTco1::MatchPatTupleOne( - pat.clone(), - item.clone(), - restPats.clone(), - restItems.clone(), - acc.clone(), + pat, item, restPats, restItems, acc, )) } @@ -289,9 +281,9 @@ pub fn matchPatTupleItems( ) -> Result, AverStr> { crate::cancel_checkpoint(); crate::aver_generated::domain::match_mod::matchPatTupleItemsAcc( - pats, - items, - &aver_rt::AverList::empty(), + pats.clone(), + items.clone(), + aver_rt::AverList::empty(), ) } diff --git a/src/self_host/aver_generated/domain/parser/expr/mod.rs b/src/self_host/aver_generated/domain/parser/expr/mod.rs index a3bc70ca0..e6ee2cad7 100644 --- a/src/self_host/aver_generated/domain/parser/expr/mod.rs +++ b/src/self_host/aver_generated/domain/parser/expr/mod.rs @@ -73,22 +73,19 @@ fn __mutual_tco_trampoline_1( pub fn parseAddExprTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - left @ _: &crate::aver_generated::domain::ast::Expr, + left @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_1(__MutualTco1::ParseAddExprTail(pos, left.clone()), &tokens) + __mutual_tco_trampoline_1(__MutualTco1::ParseAddExprTail(pos, left), &tokens) } /// Parse right side of additive op. pub fn parseAddExprRight( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - left @ _: &crate::aver_generated::domain::ast::Expr, + left @ _: crate::aver_generated::domain::ast::Expr, op @ _: aver_rt::AverInt, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_1( - __MutualTco1::ParseAddExprRight(pos, left.clone(), op), - &tokens, - ) + __mutual_tco_trampoline_1(__MutualTco1::ParseAddExprRight(pos, left, op), &tokens) } #[allow(non_camel_case_types)] @@ -160,22 +157,19 @@ fn __mutual_tco_trampoline_2( pub fn parseMulExprTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - left @ _: &crate::aver_generated::domain::ast::Expr, + left @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_2(__MutualTco2::ParseMulExprTail(pos, left.clone()), &tokens) + __mutual_tco_trampoline_2(__MutualTco2::ParseMulExprTail(pos, left), &tokens) } /// Parse right side of mul/div op. pub fn parseMulExprRight( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - left @ _: &crate::aver_generated::domain::ast::Expr, + left @ _: crate::aver_generated::domain::ast::Expr, op @ _: aver_rt::AverInt, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_2( - __MutualTco2::ParseMulExprRight(pos, left.clone(), op), - &tokens, - ) + __mutual_tco_trampoline_2(__MutualTco2::ParseMulExprRight(pos, left, op), &tokens) } #[allow(non_camel_case_types)] @@ -269,31 +263,28 @@ fn __mutual_tco_trampoline_3( pub fn parseMapEntries( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_3(__MutualTco3::ParseMapEntries(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_3(__MutualTco3::ParseMapEntries(pos, acc), &tokens) } /// After key, expect => then value. pub fn parseMapAfterKey( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, - keyExpr @ _: &crate::aver_generated::domain::ast::Expr, + acc @ _: aver_rt::AverList, + keyExpr @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_3( - __MutualTco3::ParseMapAfterKey(pos, acc.clone(), keyExpr.clone()), - &tokens, - ) + __mutual_tco_trampoline_3(__MutualTco3::ParseMapAfterKey(pos, acc, keyExpr), &tokens) } /// After entry: , for more or } to end. pub fn parseMapEntryTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_3(__MutualTco3::ParseMapEntryTail(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_3(__MutualTco3::ParseMapEntryTail(pos, acc), &tokens) } #[allow(non_camel_case_types)] @@ -388,39 +379,36 @@ fn __mutual_tco_trampoline_4( pub fn parseInterpParts( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_4(__MutualTco4::ParseInterpParts(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_4(__MutualTco4::ParseInterpParts(pos, acc), &tokens) } /// After interpolation expr: expect TkInterpEnd, then maybe more string. pub fn parseInterpAfterExpr( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_4( - __MutualTco4::ParseInterpAfterExpr(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_4(__MutualTco4::ParseInterpAfterExpr(pos, acc), &tokens) } /// After }: next TkStr continues, or end of string. pub fn parseInterpContinue( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_4(__MutualTco4::ParseInterpContinue(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_4(__MutualTco4::ParseInterpContinue(pos, acc), &tokens) } /// After string segment: more interpolation or end. pub fn parseInterpAfterStr( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_4(__MutualTco4::ParseInterpAfterStr(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_4(__MutualTco4::ParseInterpAfterStr(pos, acc), &tokens) } #[allow(non_camel_case_types)] @@ -496,33 +484,27 @@ fn __mutual_tco_trampoline_5( pub fn parseListItems( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_5(__MutualTco5::ParseListItems(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_5(__MutualTco5::ParseListItems(pos, acc), &tokens) } /// After a list item: ',' for more or ']' to end. pub fn parseListItemsTail( tokens @ _: &aver_rt::AverList, pos0 @ _: aver_rt::AverInt, - items @ _: &aver_rt::AverList, + items @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_5( - __MutualTco5::ParseListItemsTail(pos0, items.clone()), - &tokens, - ) + __mutual_tco_trampoline_5(__MutualTco5::ParseListItemsTail(pos0, items), &tokens) } /// Allow a trailing comma before ']' in list literals. pub fn parseListAfterComma( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - items @ _: &aver_rt::AverList, + items @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_5( - __MutualTco5::ParseListAfterComma(pos, items.clone()), - &tokens, - ) + __mutual_tco_trampoline_5(__MutualTco5::ParseListAfterComma(pos, items), &tokens) } #[allow(non_camel_case_types)] @@ -600,33 +582,27 @@ fn __mutual_tco_trampoline_6( pub fn parseTupleRest( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_6(__MutualTco6::ParseTupleRest(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_6(__MutualTco6::ParseTupleRest(pos, acc), &tokens) } /// After tuple element: ',' for more or ')' to end. pub fn parseTupleRestTail( tokens @ _: &aver_rt::AverList, pos0 @ _: aver_rt::AverInt, - items @ _: &aver_rt::AverList, + items @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_6( - __MutualTco6::ParseTupleRestTail(pos0, items.clone()), - &tokens, - ) + __mutual_tco_trampoline_6(__MutualTco6::ParseTupleRestTail(pos0, items), &tokens) } /// Allow a trailing comma before ')' in tuples. pub fn parseTupleAfterComma( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - items @ _: &aver_rt::AverList, + items @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_6( - __MutualTco6::ParseTupleAfterComma(pos, items.clone()), - &tokens, - ) + __mutual_tco_trampoline_6(__MutualTco6::ParseTupleAfterComma(pos, items), &tokens) } #[allow(non_camel_case_types)] @@ -676,21 +652,18 @@ fn __mutual_tco_trampoline_7( pub fn parseFieldAccess( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - obj @ _: &crate::aver_generated::domain::ast::Expr, + obj @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_7(__MutualTco7::ParseFieldAccess(pos, obj.clone()), &tokens) + __mutual_tco_trampoline_7(__MutualTco7::ParseFieldAccess(pos, obj), &tokens) } /// Check for chained field access. pub fn parseFieldAccessTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - expr @ _: &crate::aver_generated::domain::ast::Expr, + expr @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_7( - __MutualTco7::ParseFieldAccessTail(pos, expr.clone()), - &tokens, - ) + __mutual_tco_trampoline_7(__MutualTco7::ParseFieldAccessTail(pos, expr), &tokens) } #[allow(non_camel_case_types)] @@ -808,12 +781,9 @@ pub fn parseRecordFields( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - acc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + acc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_8( - __MutualTco8::ParseRecordFields(pos, name, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_8(__MutualTco8::ParseRecordFields(pos, name, acc), &tokens) } /// Parse = expr after field name. @@ -821,11 +791,11 @@ pub fn parseRecordField( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - acc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + acc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, field @ _: AverStr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_8( - __MutualTco8::ParseRecordField(pos, name, acc.clone(), field), + __MutualTco8::ParseRecordField(pos, name, acc, field), &tokens, ) } @@ -835,10 +805,10 @@ pub fn parseRecordFieldsTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - fields @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + fields @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_8( - __MutualTco8::ParseRecordFieldsTail(pos, name, fields.clone()), + __MutualTco8::ParseRecordFieldsTail(pos, name, fields), &tokens, ) } @@ -848,10 +818,10 @@ pub fn parseRecordAfterComma( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - fields @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + fields @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_8( - __MutualTco8::ParseRecordAfterComma(pos, name, fields.clone()), + __MutualTco8::ParseRecordAfterComma(pos, name, fields), &tokens, ) } @@ -961,7 +931,7 @@ fn __mutual_tco_trampoline_9( pos, name, &args, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ); } _ => __MutualTco9::ParseCallArgsList(pos, name, args), @@ -976,12 +946,9 @@ pub fn parseCallArgsList( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_9( - __MutualTco9::ParseCallArgsList(pos, name, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_9(__MutualTco9::ParseCallArgsList(pos, name, acc), &tokens) } /// After an argument: ',' for more or ')' to end. Detects named args (field = expr). @@ -989,10 +956,10 @@ pub fn parseCallArgsListTail( tokens @ _: &aver_rt::AverList, pos0 @ _: aver_rt::AverInt, name @ _: AverStr, - args @ _: &aver_rt::AverList, + args @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_9( - __MutualTco9::ParseCallArgsListTail(pos0, name, args.clone()), + __MutualTco9::ParseCallArgsListTail(pos0, name, args), &tokens, ) } @@ -1002,10 +969,10 @@ pub fn parseCallArgsAfterComma( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - args @ _: &aver_rt::AverList, + args @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_9( - __MutualTco9::ParseCallArgsAfterComma(pos, name, args.clone()), + __MutualTco9::ParseCallArgsAfterComma(pos, name, args), &tokens, ) } @@ -1015,11 +982,11 @@ pub fn parseCallArgsCheckNamed( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - args @ _: &aver_rt::AverList, + args @ _: aver_rt::AverList, field @ _: AverStr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_9( - __MutualTco9::ParseCallArgsCheckNamed(pos, name, args.clone(), field), + __MutualTco9::ParseCallArgsCheckNamed(pos, name, args, field), &tokens, ) } @@ -1153,10 +1120,10 @@ pub fn parseNamedArgs( pos @ _: aver_rt::AverInt, name @ _: AverStr, positionalArgs @ _: &aver_rt::AverList, - namedAcc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + namedAcc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_10( - __MutualTco10::ParseNamedArgs(pos, name, namedAcc.clone()), + __MutualTco10::ParseNamedArgs(pos, name, namedAcc), &tokens, &positionalArgs, ) @@ -1168,11 +1135,11 @@ pub fn parseNamedArgField( pos @ _: aver_rt::AverInt, name @ _: AverStr, positionalArgs @ _: &aver_rt::AverList, - namedAcc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + namedAcc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, field @ _: AverStr, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_10( - __MutualTco10::ParseNamedArgField(pos, name, namedAcc.clone(), field), + __MutualTco10::ParseNamedArgField(pos, name, namedAcc, field), &tokens, &positionalArgs, ) @@ -1184,10 +1151,10 @@ pub fn parseNamedArgsTail( pos0 @ _: aver_rt::AverInt, name @ _: AverStr, positionalArgs @ _: &aver_rt::AverList, - namedAcc @ _: &aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, + namedAcc @ _: aver_rt::AverList<(AverStr, crate::aver_generated::domain::ast::Expr)>, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_10( - __MutualTco10::ParseNamedArgsTail(pos0, name, namedAcc.clone()), + __MutualTco10::ParseNamedArgsTail(pos0, name, namedAcc), &tokens, &positionalArgs, ) @@ -1300,13 +1267,9 @@ pub fn parseMatchArms( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_11( - __MutualTco11::ParseMatchArms(pos, acc.clone()), - &tokens, - &subject, - ) + __mutual_tco_trampoline_11(__MutualTco11::ParseMatchArms(pos, acc), &tokens, &subject) } /// Parse one match arm: pattern '->' expr NEWLINE @@ -1314,13 +1277,9 @@ pub fn parseOneArm( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_11( - __MutualTco11::ParseOneArm(pos, acc.clone()), - &tokens, - &subject, - ) + __mutual_tco_trampoline_11(__MutualTco11::ParseOneArm(pos, acc), &tokens, &subject) } /// Parse arrow and body of a match arm. @@ -1328,11 +1287,11 @@ pub fn parseOneArmBody( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, - pat @ _: &crate::aver_generated::domain::ast::Pattern, + acc @ _: aver_rt::AverList, + pat @ _: crate::aver_generated::domain::ast::Pattern, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_11( - __MutualTco11::ParseOneArmBody(pos, acc.clone(), pat.clone()), + __MutualTco11::ParseOneArmBody(pos, acc, pat), &tokens, &subject, ) @@ -1428,10 +1387,10 @@ pub fn parseMatchArmsFlat( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_12( - __MutualTco12::ParseMatchArmsFlat(pos, acc.clone()), + __MutualTco12::ParseMatchArmsFlat(pos, acc), &tokens, &subject, ) @@ -1442,13 +1401,9 @@ pub fn parseOneArmFlat( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_12( - __MutualTco12::ParseOneArmFlat(pos, acc.clone()), - &tokens, - &subject, - ) + __mutual_tco_trampoline_12(__MutualTco12::ParseOneArmFlat(pos, acc), &tokens, &subject) } /// Parse arrow and body, then continue flat. @@ -1456,11 +1411,11 @@ pub fn parseOneArmFlatBody( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, subject @ _: &crate::aver_generated::domain::ast::Expr, - acc @ _: &aver_rt::AverList, - pat @ _: &crate::aver_generated::domain::ast::Pattern, + acc @ _: aver_rt::AverList, + pat @ _: crate::aver_generated::domain::ast::Pattern, ) -> Result<(crate::aver_generated::domain::ast::Expr, aver_rt::AverInt), AverStr> { __mutual_tco_trampoline_12( - __MutualTco12::ParseOneArmFlatBody(pos, acc.clone(), pat.clone()), + __MutualTco12::ParseOneArmFlatBody(pos, acc, pat), &tokens, &subject, ) @@ -1670,7 +1625,7 @@ pub fn parseAddExpr( let r @ _ = crate::aver_generated::domain::parser::expr::parseMulExpr(tokens, pos)?; { let (expr, pos2) = r; - crate::aver_generated::domain::parser::expr::parseAddExprTail(tokens, pos2, &expr) + crate::aver_generated::domain::parser::expr::parseAddExprTail(tokens, pos2, expr) } } @@ -1683,7 +1638,7 @@ pub fn parseMulExpr( let r @ _ = crate::aver_generated::domain::parser::expr::parseAtom(tokens, pos)?; { let (expr, pos2) = r; - crate::aver_generated::domain::parser::expr::parseMulExprTail(tokens, pos2, &expr) + crate::aver_generated::domain::parser::expr::parseMulExprTail(tokens, pos2, expr) } } @@ -1769,7 +1724,7 @@ pub fn parseMapLiteral( _ => crate::aver_generated::domain::parser::expr::parseMapEntries( tokens, pos2, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ), } } @@ -1802,7 +1757,7 @@ pub fn parseStringOrInterp( crate::aver_generated::domain::parser::expr::parseInterpParts( tokens, pos.add(&aver_rt::AverInt::from_i64(1)), - &aver_rt::AverList::from_vec(vec![ + aver_rt::AverList::from_vec(vec![ crate::aver_generated::domain::ast::Expr::ExprStr(prefix), ]), ) @@ -1829,7 +1784,7 @@ pub fn parseListExpr( _ => crate::aver_generated::domain::parser::expr::parseListItems( tokens, pos, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ), } } @@ -1848,7 +1803,7 @@ pub fn parseParenExpr( crate::aver_generated::domain::parser::expr::parseTupleRest( tokens, pos2.add(&aver_rt::AverInt::from_i64(1)), - &aver_rt::AverList::from_vec(vec![expr]), + aver_rt::AverList::from_vec(vec![expr]), ) } crate::aver_generated::domain::token::Token::TkRParen => { @@ -1926,7 +1881,7 @@ pub fn parseIdentOrCall( crate::aver_generated::domain::parser::expr::parseFieldAccess( tokens, nextPos, - &crate::aver_generated::domain::ast::Expr::ExprVar(name), + crate::aver_generated::domain::ast::Expr::ExprVar(name), ) } _ => Ok((crate::aver_generated::domain::ast::Expr::ExprVar(name), pos)), @@ -1943,7 +1898,7 @@ pub fn chainFieldAccess( let r @ _ = crate::aver_generated::domain::parser::expr::parseCallOrRecord(tokens, pos, name)?; { let (expr, pos2) = r; - crate::aver_generated::domain::parser::expr::parseFieldAccessTail(tokens, pos2, &expr) + crate::aver_generated::domain::parser::expr::parseFieldAccessTail(tokens, pos2, expr) } } @@ -2001,7 +1956,7 @@ pub fn parseCallOrRecord( tokens, pos2, name, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ), } } @@ -2023,14 +1978,14 @@ pub fn parseCallOrRecordLookahead( tokens, pos, name, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ) } _ => crate::aver_generated::domain::parser::expr::parseCallArgsList( tokens, pos, name, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ), } } @@ -2062,14 +2017,14 @@ pub fn parseMatchAfterSubject( tokens, pos2.add(&aver_rt::AverInt::from_i64(1)), subject, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ) } _ => crate::aver_generated::domain::parser::expr::parseMatchArmsFlat( tokens, pos2, subject, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ), } } diff --git a/src/self_host/aver_generated/domain/parser/mod.rs b/src/self_host/aver_generated/domain/parser/mod.rs index c25ffbe97..bf7ac1efd 100644 --- a/src/self_host/aver_generated/domain/parser/mod.rs +++ b/src/self_host/aver_generated/domain/parser/mod.rs @@ -58,7 +58,7 @@ fn __mutual_tco_trampoline_1( pub fn parseFnBodyStmtsIndented( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( aver_rt::AverList, @@ -66,17 +66,14 @@ pub fn parseFnBodyStmtsIndented( ), AverStr, > { - __mutual_tco_trampoline_1( - __MutualTco1::ParseFnBodyStmtsIndented(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_1(__MutualTco1::ParseFnBodyStmtsIndented(pos, acc), &tokens) } /// Parse one statement and continue with indented body. pub fn parseFnBodyOneStmtIndented( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( aver_rt::AverList, @@ -84,10 +81,7 @@ pub fn parseFnBodyOneStmtIndented( ), AverStr, > { - __mutual_tco_trampoline_1( - __MutualTco1::ParseFnBodyOneStmtIndented(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_1(__MutualTco1::ParseFnBodyOneStmtIndented(pos, acc), &tokens) } #[allow(non_camel_case_types)] @@ -158,7 +152,7 @@ fn __mutual_tco_trampoline_2( pub fn parseFnBodyStmtsFlat( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( aver_rt::AverList, @@ -166,17 +160,14 @@ pub fn parseFnBodyStmtsFlat( ), AverStr, > { - __mutual_tco_trampoline_2( - __MutualTco2::ParseFnBodyStmtsFlat(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_2(__MutualTco2::ParseFnBodyStmtsFlat(pos, acc), &tokens) } /// Parse one statement in function body and continue (flat mode). pub fn parseFnBodyOneStmtFlat( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( aver_rt::AverList, @@ -184,17 +175,14 @@ pub fn parseFnBodyOneStmtFlat( ), AverStr, > { - __mutual_tco_trampoline_2( - __MutualTco2::ParseFnBodyOneStmtFlat(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_2(__MutualTco2::ParseFnBodyOneStmtFlat(pos, acc), &tokens) } /// After a body statement: single newline continues, anything else ends (flat mode). pub fn parseFnBodyAfterStmtFlat( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( aver_rt::AverList, @@ -202,10 +190,7 @@ pub fn parseFnBodyAfterStmtFlat( ), AverStr, > { - __mutual_tco_trampoline_2( - __MutualTco2::ParseFnBodyAfterStmtFlat(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_2(__MutualTco2::ParseFnBodyAfterStmtFlat(pos, acc), &tokens) } #[allow(non_camel_case_types)] @@ -392,27 +377,24 @@ fn __mutual_tco_trampoline_3( pub fn parseProgram( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - deps @ _: &aver_rt::AverList, - fns @ _: &aver_rt::AverList, - stmts @ _: &aver_rt::AverList, + deps @ _: aver_rt::AverList, + fns @ _: aver_rt::AverList, + stmts @ _: aver_rt::AverList, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::ParseProgram(pos, deps.clone(), fns.clone(), stmts.clone()), - &tokens, - ) + __mutual_tco_trampoline_3(__MutualTco3::ParseProgram(pos, deps, fns, stmts), &tokens) } /// Handle keywords: module (extract depends), type/record/verify/decision (skip). pub fn parseProgramKeyword( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - deps @ _: &aver_rt::AverList, - fns @ _: &aver_rt::AverList, - stmts @ _: &aver_rt::AverList, + deps @ _: aver_rt::AverList, + fns @ _: aver_rt::AverList, + stmts @ _: aver_rt::AverList, kw @ _: AverStr, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::ParseProgramKeyword(pos, deps.clone(), fns.clone(), stmts.clone(), kw), + __MutualTco3::ParseProgramKeyword(pos, deps, fns, stmts, kw), &tokens, ) } @@ -421,11 +403,11 @@ pub fn parseProgramKeyword( pub fn parseProgramModuleHeader( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - fns @ _: &aver_rt::AverList, - stmts @ _: &aver_rt::AverList, + fns @ _: aver_rt::AverList, + stmts @ _: aver_rt::AverList, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::ParseProgramModuleHeader(pos, fns.clone(), stmts.clone()), + __MutualTco3::ParseProgramModuleHeader(pos, fns, stmts), &tokens, ) } @@ -434,26 +416,23 @@ pub fn parseProgramModuleHeader( pub fn parseProgramFn( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - deps @ _: &aver_rt::AverList, - fns @ _: &aver_rt::AverList, - stmts @ _: &aver_rt::AverList, + deps @ _: aver_rt::AverList, + fns @ _: aver_rt::AverList, + stmts @ _: aver_rt::AverList, ) -> Result { - __mutual_tco_trampoline_3( - __MutualTco3::ParseProgramFn(pos, deps.clone(), fns.clone(), stmts.clone()), - &tokens, - ) + __mutual_tco_trampoline_3(__MutualTco3::ParseProgramFn(pos, deps, fns, stmts), &tokens) } /// Parse a statement and continue. pub fn parseProgramStmt( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - deps @ _: &aver_rt::AverList, - fns @ _: &aver_rt::AverList, - stmts @ _: &aver_rt::AverList, + deps @ _: aver_rt::AverList, + fns @ _: aver_rt::AverList, + stmts @ _: aver_rt::AverList, ) -> Result { __mutual_tco_trampoline_3( - __MutualTco3::ParseProgramStmt(pos, deps.clone(), fns.clone(), stmts.clone()), + __MutualTco3::ParseProgramStmt(pos, deps, fns, stmts), &tokens, ) } @@ -659,7 +638,7 @@ pub fn parseStmtExprFrom( let ir @ _ = crate::aver_generated::domain::parser::expr::parseIdentOrCall(tokens, pos, name)?; { let (expr, pos2) = ir; - crate::aver_generated::domain::parser::parseStmtExprFromMul(tokens, pos2, &expr) + crate::aver_generated::domain::parser::parseStmtExprFromMul(tokens, pos2, expr) } } @@ -667,13 +646,13 @@ pub fn parseStmtExprFrom( pub fn parseStmtExprFromMul( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - expr @ _: &crate::aver_generated::domain::ast::Expr, + mut expr @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Stmt, aver_rt::AverInt), AverStr> { crate::cancel_checkpoint(); let mr @ _ = crate::aver_generated::domain::parser::expr::parseMulExprTail(tokens, pos, expr)?; { let (expr2, pos2) = mr; - crate::aver_generated::domain::parser::parseStmtExprFromAdd(tokens, pos2, &expr2) + crate::aver_generated::domain::parser::parseStmtExprFromAdd(tokens, pos2, expr2) } } @@ -681,7 +660,7 @@ pub fn parseStmtExprFromMul( pub fn parseStmtExprFromAdd( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - expr @ _: &crate::aver_generated::domain::ast::Expr, + mut expr @ _: crate::aver_generated::domain::ast::Expr, ) -> Result<(crate::aver_generated::domain::ast::Stmt, aver_rt::AverInt), AverStr> { crate::cancel_checkpoint(); let ar @ _ = crate::aver_generated::domain::parser::expr::parseAddExprTail(tokens, pos, expr)?; @@ -759,7 +738,7 @@ pub fn parseFnDefParams( let pr @ _ = crate::aver_generated::domain::parser_match::parseParamList( tokens, pos2, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), )?; { let (params, pos3) = pr; @@ -803,7 +782,7 @@ pub fn parseFnDefBodyIndented( let sr @ _ = crate::aver_generated::domain::parser::parseFnBodyStmtsIndented( tokens, pos2, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), )?; { let (stmts, pos3) = sr; @@ -835,7 +814,7 @@ pub fn parseFnDefBodyFlat( let sr @ _ = crate::aver_generated::domain::parser::parseFnBodyStmtsFlat( tokens, pos2, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), )?; { let (stmts, pos3) = sr; @@ -863,9 +842,9 @@ pub fn parse( crate::aver_generated::domain::parser::parseProgram( tokens, aver_rt::AverInt::from_i64(0), - &aver_rt::AverList::empty(), - &aver_rt::AverList::empty(), - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), + aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ) } diff --git a/src/self_host/aver_generated/domain/parser_match/mod.rs b/src/self_host/aver_generated/domain/parser_match/mod.rs index c029486cf..0417c6a4b 100644 --- a/src/self_host/aver_generated/domain/parser_match/mod.rs +++ b/src/self_host/aver_generated/domain/parser_match/mod.rs @@ -27,7 +27,7 @@ fn __mutual_tco_trampoline_1( __MutualTco1::ParseIdentPatternDotted(nextPos, name) }, crate::aver_generated::domain::token::Token::TkLParen => { - return crate::aver_generated::domain::parser_match::parseConstructorPatternBindings(&*tokens, nextPos, name, &aver_rt::AverList::empty()) + return crate::aver_generated::domain::parser_match::parseConstructorPatternBindings(&*tokens, nextPos, name, aver_rt::AverList::empty()) }, _ => { if name.contains(".") { return Ok((crate::aver_generated::domain::ast::Pattern::PatConstructor(name, aver_rt::AverList::empty()), pos)) } else { return Ok((crate::aver_generated::domain::ast::Pattern::PatVar(name), pos)) } @@ -162,7 +162,7 @@ pub fn parseConstructorPatternBindings( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( crate::aver_generated::domain::ast::Pattern, @@ -171,7 +171,7 @@ pub fn parseConstructorPatternBindings( AverStr, > { __mutual_tco_trampoline_2( - __MutualTco2::ParseConstructorPatternBindings(pos, name, acc.clone()), + __MutualTco2::ParseConstructorPatternBindings(pos, name, acc), &tokens, ) } @@ -181,7 +181,7 @@ pub fn parseConstructorPatternTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, name @ _: AverStr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( crate::aver_generated::domain::ast::Pattern, @@ -190,7 +190,7 @@ pub fn parseConstructorPatternTail( AverStr, > { __mutual_tco_trampoline_2( - __MutualTco2::ParseConstructorPatternTail(pos, name, acc.clone()), + __MutualTco2::ParseConstructorPatternTail(pos, name, acc), &tokens, ) } @@ -273,7 +273,7 @@ fn __mutual_tco_trampoline_3( pub fn parseTuplePatternElements( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( crate::aver_generated::domain::ast::Pattern, @@ -281,17 +281,14 @@ pub fn parseTuplePatternElements( ), AverStr, > { - __mutual_tco_trampoline_3( - __MutualTco3::ParseTuplePatternElements(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_3(__MutualTco3::ParseTuplePatternElements(pos, acc), &tokens) } /// Parse one pattern element and continue. pub fn parseTuplePatternElement( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( crate::aver_generated::domain::ast::Pattern, @@ -299,17 +296,14 @@ pub fn parseTuplePatternElement( ), AverStr, > { - __mutual_tco_trampoline_3( - __MutualTco3::ParseTuplePatternElement(pos, acc.clone()), - &tokens, - ) + __mutual_tco_trampoline_3(__MutualTco3::ParseTuplePatternElement(pos, acc), &tokens) } /// After element: ',' for more or ')' to end. pub fn parseTuplePatternElementTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result< ( crate::aver_generated::domain::ast::Pattern, @@ -318,7 +312,7 @@ pub fn parseTuplePatternElementTail( AverStr, > { __mutual_tco_trampoline_3( - __MutualTco3::ParseTuplePatternElementTail(pos, acc.clone()), + __MutualTco3::ParseTuplePatternElementTail(pos, acc), &tokens, ) } @@ -449,18 +443,18 @@ fn __mutual_tco_trampoline_5( pub fn parseParamList( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(aver_rt::AverList, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_5(__MutualTco5::ParseParamList(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_5(__MutualTco5::ParseParamList(pos, acc), &tokens) } /// After a param name: ',' for more or ')' to end. pub fn parseParamListTail( tokens @ _: &aver_rt::AverList, pos @ _: aver_rt::AverInt, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, ) -> Result<(aver_rt::AverList, aver_rt::AverInt), AverStr> { - __mutual_tco_trampoline_5(__MutualTco5::ParseParamListTail(pos, acc.clone()), &tokens) + __mutual_tco_trampoline_5(__MutualTco5::ParseParamListTail(pos, acc), &tokens) } /// Token at position, or TkEof if past end. @@ -690,7 +684,7 @@ pub fn parseTuplePattern( crate::aver_generated::domain::parser_match::parseTuplePatternElements( tokens, pos, - &aver_rt::AverList::empty(), + aver_rt::AverList::empty(), ) } diff --git a/src/self_host/aver_generated/domain/resolver/core/mod.rs b/src/self_host/aver_generated/domain/resolver/core/mod.rs index fad3a7d29..0261b5a36 100644 --- a/src/self_host/aver_generated/domain/resolver/core/mod.rs +++ b/src/self_host/aver_generated/domain/resolver/core/mod.rs @@ -30,9 +30,9 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { __MutualTco1::MaxSlotInExpr( elseExpr, crate::aver_generated::domain::resolver::core::maxSlotInExpr( - &thenExpr, + thenExpr, crate::aver_generated::domain::resolver::core::maxSlotInExpr( - &cond, acc, + cond, acc, ), ), ) @@ -74,7 +74,7 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { __MutualTco1::MaxSlotInExpr( idxExpr, crate::aver_generated::domain::resolver::core::maxSlotInExpr( - &vecExpr, acc, + vecExpr, acc, ), ) } @@ -83,7 +83,7 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { let b = (*b).clone(); __MutualTco1::MaxSlotInExpr( b, - crate::aver_generated::domain::resolver::core::maxSlotInExpr(&a, acc), + crate::aver_generated::domain::resolver::core::maxSlotInExpr(a, acc), ) } crate::aver_generated::domain::ast::Expr::ExprAdd(a, b) => { @@ -170,9 +170,7 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { let subj = (*subj).clone(); return crate::aver_generated::domain::resolver::core::maxSlotInArms( arms, - crate::aver_generated::domain::resolver::core::maxSlotInExpr( - &subj, acc, - ), + crate::aver_generated::domain::resolver::core::maxSlotInExpr(subj, acc), ); } crate::aver_generated::domain::ast::Expr::ExprPropagate(inner) => { @@ -215,7 +213,7 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { crate::cancel_checkpoint(); __MutualTco1::MaxSlotInExpr( b, - crate::aver_generated::domain::resolver::core::maxSlotInExpr(&a, acc), + crate::aver_generated::domain::resolver::core::maxSlotInExpr(a, acc), ) } }; @@ -224,35 +222,35 @@ fn __mutual_tco_trampoline_1(mut __state: __MutualTco1) -> aver_rt::AverInt { /// Find highest slot index in an expression tree. pub fn maxSlotInExpr( - expr @ _: &crate::aver_generated::domain::ast::Expr, + expr @ _: crate::aver_generated::domain::ast::Expr, acc @ _: aver_rt::AverInt, ) -> aver_rt::AverInt { - __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExpr(expr.clone(), acc)) + __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExpr(expr, acc)) } /// Continue max-slot traversal for composite expression forms. pub fn maxSlotInExprComposite( - expr @ _: &crate::aver_generated::domain::ast::Expr, + expr @ _: crate::aver_generated::domain::ast::Expr, acc @ _: aver_rt::AverInt, ) -> aver_rt::AverInt { - __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprComposite(expr.clone(), acc)) + __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprComposite(expr, acc)) } /// Finish max-slot traversal for aggregate and call expression forms. pub fn maxSlotInExprAggregate( - expr @ _: &crate::aver_generated::domain::ast::Expr, + expr @ _: crate::aver_generated::domain::ast::Expr, acc @ _: aver_rt::AverInt, ) -> aver_rt::AverInt { - __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprAggregate(expr.clone(), acc)) + __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprAggregate(expr, acc)) } /// Visit both sides of a binary expression. pub fn maxSlotInExprPair( - a @ _: &crate::aver_generated::domain::ast::Expr, - b @ _: &crate::aver_generated::domain::ast::Expr, + a @ _: crate::aver_generated::domain::ast::Expr, + b @ _: crate::aver_generated::domain::ast::Expr, acc @ _: aver_rt::AverInt, ) -> aver_rt::AverInt { - __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprPair(a.clone(), b.clone(), acc)) + __mutual_tco_trampoline_1(__MutualTco1::MaxSlotInExprPair(a, b, acc)) } /// Resolve each function definition. @@ -387,15 +385,15 @@ pub fn maxSlotInStmt( match s.clone() { crate::aver_generated::domain::ast::Stmt::StmtBindSlot(slot, expr) => { crate::aver_generated::domain::resolver::core::maxSlotInExpr( - &expr, + expr, crate::aver_generated::domain::resolver::core::maxInt(slot, acc), ) } crate::aver_generated::domain::ast::Stmt::StmtExpr(expr) => { - crate::aver_generated::domain::resolver::core::maxSlotInExpr(&expr, acc) + crate::aver_generated::domain::resolver::core::maxSlotInExpr(expr, acc) } crate::aver_generated::domain::ast::Stmt::StmtBind(_, expr) => { - crate::aver_generated::domain::resolver::core::maxSlotInExpr(&expr, acc) + crate::aver_generated::domain::resolver::core::maxSlotInExpr(expr, acc) } } } @@ -410,7 +408,7 @@ pub fn maxSlotInExprs( crate::cancel_checkpoint(); aver_list_match!(exprs, [] => { return acc; }, [e, rest] => { { let __tco0 = rest; - let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(&e, acc); + let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(e, acc); exprs = __tco0; acc = __tco1; continue; @@ -428,7 +426,7 @@ pub fn maxSlotInFields( crate::cancel_checkpoint(); aver_list_match!(fields, [] => { return acc; }, [pair, rest] => { { let (_, expr) = pair; { let __tco0 = rest; - let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(&expr, acc); + let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(expr, acc); fields = __tco0; acc = __tco1; continue; @@ -446,7 +444,7 @@ pub fn maxSlotInArms( crate::cancel_checkpoint(); aver_list_match!(arms, [] => { return acc; }, [arm, rest] => { { let __tco0 = rest; - let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(&arm.body, acc); + let __tco1 = crate::aver_generated::domain::resolver::core::maxSlotInExpr(arm.body, acc); arms = __tco0; acc = __tco1; continue; diff --git a/src/self_host/aver_generated/entry/mod.rs b/src/self_host/aver_generated/entry/mod.rs index 31bdb59c3..e6c3adde4 100644 --- a/src/self_host/aver_generated/entry/mod.rs +++ b/src/self_host/aver_generated/entry/mod.rs @@ -54,27 +54,27 @@ fn __mutual_tco_trampoline_1( /// Synthesized indexed worker of `qualifyFns`. Its hidden String.Index is built by the ABI-preserving wrapper and forwarded through the recursive string-flow component. pub fn qualifyFns__indexed( - fns @ _: &aver_rt::AverList, + fns @ _: aver_rt::AverList, prefix @ _: AverStr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, __str_index @ _: &aver_rt::StringIndex, ) -> aver_rt::AverList { __mutual_tco_trampoline_1( - __MutualTco1::QualifyFns__indexed(fns.clone(), prefix, acc.clone()), + __MutualTco1::QualifyFns__indexed(fns, prefix, acc), &__str_index, ) } /// Synthesized indexed worker of `qualifyFnsOne`. Its hidden String.Index is built by the ABI-preserving wrapper and forwarded through the recursive string-flow component. pub fn qualifyFnsOne__indexed( - f @ _: &crate::aver_generated::domain::ast::FnDef, - rest @ _: &aver_rt::AverList, + f @ _: crate::aver_generated::domain::ast::FnDef, + rest @ _: aver_rt::AverList, prefix @ _: AverStr, - acc @ _: &aver_rt::AverList, + acc @ _: aver_rt::AverList, __str_index @ _: &aver_rt::StringIndex, ) -> aver_rt::AverList { __mutual_tco_trampoline_1( - __MutualTco1::QualifyFnsOne__indexed(f.clone(), rest.clone(), prefix, acc.clone()), + __MutualTco1::QualifyFnsOne__indexed(f, rest, prefix, acc), &__str_index, ) } @@ -263,9 +263,9 @@ pub fn qualifyFns( ) -> aver_rt::AverList { crate::cancel_checkpoint(); qualifyFns__indexed( - fns, + fns.clone(), prefix.clone(), - acc, + acc.clone(), &aver_rt::string_index_build(&prefix), ) } @@ -273,7 +273,7 @@ pub fn qualifyFns( /// Add both qualified and unqualified versions. #[inline(always)] pub fn qualifyFnsOne( - f @ _: &crate::aver_generated::domain::ast::FnDef, + mut f @ _: crate::aver_generated::domain::ast::FnDef, rest @ _: &aver_rt::AverList, prefix @ _: AverStr, acc @ _: &aver_rt::AverList, @@ -281,9 +281,9 @@ pub fn qualifyFnsOne( crate::cancel_checkpoint(); qualifyFnsOne__indexed( f, - rest, + rest.clone(), prefix.clone(), - acc, + acc.clone(), &aver_rt::string_index_build(&prefix), ) } @@ -1354,7 +1354,12 @@ pub fn resolveQualifiedModuleFns__indexed( crate::cancel_checkpoint(); let qualifiedProg @ _ = crate::aver_generated::domain::ast::Program { deps: prog.deps.clone(), - fns: qualifyFns__indexed(&prog.fns, dep, &aver_rt::AverList::empty(), __str_index), + fns: qualifyFns__indexed( + prog.fns.clone(), + dep, + aver_rt::AverList::empty(), + __str_index, + ), stmts: prog.stmts.clone(), }; crate::aver_generated::domain::resolver::resolveProgram(qualifiedProg).fns diff --git a/tests/fixtures/rust_mutual_tco_by_value/main.av b/tests/fixtures/rust_mutual_tco_by_value/main.av new file mode 100644 index 000000000..b92be09b7 --- /dev/null +++ b/tests/fixtures/rust_mutual_tco_by_value/main.av @@ -0,0 +1,55 @@ +module Main + intent = "A record with a Map handed to a pair of functions that tail-call each other, once per turn of a loop." + effects [Args.get, Console.print] + +record Pool + seen: Map + turns: Int + +fn filled(seen: Map, left: Int) -> Map + ? "Keys 1 to left, each mapped to itself." + match left <= 0 + true -> seen + false -> filled(Map.set(seen, left, left), left - 1) + +verify filled + filled({}, 2) => {1 => 1, 2 => 2} + +fn pump(pool: Pool, key: Int, left: Int) -> Pool + ? "Marks key left times, handing the pool to pumped between marks." + match left <= 0 + true -> pool + false -> pumped(Pool.update(pool, seen = Map.set(pool.seen, key, left)), key, left - 1) + +verify pump + pump(Pool(seen = {}, turns = 0), 5, 1) => Pool(seen = {5 => 1}, turns = 1) + +fn pumped(pool: Pool, key: Int, left: Int) -> Pool + ? "Counts one turn and goes back to pump." + pump(Pool.update(pool, turns = pool.turns + 1), key, left) + +verify pumped + pumped(Pool(seen = {}, turns = 0), 5, 0) => Pool(seen = {}, turns = 1) + +fn turns(pool: Pool, left: Int) -> Pool + ? "One pump per turn of the loop." + match left <= 0 + true -> pool + false -> turns(pump(pool, 0 - left, 2), left - 1) + +verify turns + turns(Pool(seen = {}, turns = 0), 0) => Pool(seen = {}, turns = 0) + +fn arg(index: Int, fallback: Int) -> Int + ? "The index-th argument as an Int, or the fallback." + ! [Args.get] + match Vector.get(Vector.fromList(Args.get()), index) + Option.Some(text) -> Result.withDefault(Int.fromString(text), fallback) + Option.None -> fallback + +fn main() -> Unit + ! [Args.get, Console.print] + size = arg(0, 1000) + rounds = arg(1, 100) + done = turns(Pool(seen = filled({}, size), turns = 0), rounds) + Console.print("{Map.len(done.seen)} {done.turns}") diff --git a/tests/rust_work_spec.rs b/tests/rust_work_spec.rs index 3ccdb4801..5b3f266ac 100644 --- a/tests/rust_work_spec.rs +++ b/tests/rust_work_spec.rs @@ -517,6 +517,49 @@ fn a_record_gives_up_its_fields_at_its_last_use() { result.unwrap_or_else(|error| panic!("{error}")); } +/// A record handed to a pair of functions that tail-call each other moves +/// into the trampoline instead of being cloned by the wrapper. +/// +/// `turns` calls `pump` once per turn with its pool at its last use. The +/// wrapper used to borrow the pool and clone it into the trampoline's state, +/// so while `turns` still held its copy the first `Map.set` in the group +/// copied the whole Map, once per turn. +#[test] +fn a_mutual_tail_call_member_takes_a_record_by_value() { + let name = "rust_mutual_tco_by_value"; + let ws = temp_dir(name); + let project = ws.join("project"); + fs::create_dir_all(&project).expect("create project dir"); + let args = ["2000", "300"]; + let result = (|| { + compile_rust(name, &project, name, &[])?; + let entry = fs::read_to_string(project.join("src/aver_generated/entry/mod.rs")) + .map_err(|error| format!("read the generated entry module: {error}"))?; + for expected in [ + "pub fn pump(pool @ _: Pool, key @ _: aver_rt::AverInt, left @ _: aver_rt::AverInt) -> Pool {\n __mutual_tco_trampoline_1(__MutualTco1::Pump(pool, key, left))", + "pub fn pumped(pool @ _: Pool,", + "let __tco0 = pump(pool, ", + ] { + if !entry.contains(expected) { + return Err(format!( + "{name}: missing `{expected}` in the generated entry module:\n{entry}" + )); + } + } + let vm = run_vm_with(name, &args)?; + let bin = cargo_build(&project, name)?; + let rust = run_binary_with(&bin, &args)?; + if vm != rust { + return Err(format!( + "{name}: stdout mismatch\n--- VM ---\n{vm}\n--- Rust ---\n{rust}" + )); + } + Ok(()) + })(); + let _ = fs::remove_dir_all(&ws); + result.unwrap_or_else(|error| panic!("{error}")); +} + /// Runs one backend against a loopback peer, on a port nobody else holds. fn with_peer(run: impl FnOnce(&str) -> Result) -> Result { let port = free_port();