diff --git a/crates/compiler/derive/src/encoding.rs b/crates/compiler/derive/src/encoding.rs index 043255a665..37bd621e43 100644 --- a/crates/compiler/derive/src/encoding.rs +++ b/crates/compiler/derive/src/encoding.rs @@ -219,7 +219,6 @@ pub(crate) fn derive_to_encoder( def_symbol: Symbol, ) -> DerivedBody { let (body, body_type) = match key { - FlatEncodableKey::String => to_encoder_string(env, def_symbol), FlatEncodableKey::List() => todo!(), FlatEncodableKey::Set() => todo!(), FlatEncodableKey::Dict() => todo!(), @@ -277,97 +276,6 @@ pub(crate) fn derive_to_encoder( } } -fn to_encoder_string(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) { - // Build \s -> Encode.string s - - use Expr::*; - - let s_sym = env.new_symbol("s"); - - // build `Encode.string s` type - // Str -[uls]-> Encoder fmt | fmt has EncoderFormatting - let encode_string_fn_var = env.import_encode_symbol(Symbol::ENCODE_STRING); - - // Str -[clos]-> t1 - let string_var_slice = VariableSubsSlice::insert_into_subs(env.subs, once(Variable::STR)); // TODO: consider caching this singleton slice - let encode_string_clos_var = env.subs.fresh_unnamed_flex_var(); // clos - let encoder_var = env.subs.fresh_unnamed_flex_var(); // t1 - let this_encode_string_fn_var = synth_var( - env.subs, - Content::Structure(FlatType::Func( - string_var_slice, - encode_string_clos_var, - encoder_var, - )), - ); - - // Str -[uls]-> Encoder fmt | fmt has EncoderFormatting - // ~ Str -[clos]-> t1 - env.unify(encode_string_fn_var, this_encode_string_fn_var); - - // Encode.string : Str -[clos]-> Encoder fmt | fmt has EncoderFormatting - let encode_string_var = AbilityMember(Symbol::ENCODE_STRING, None, encode_string_fn_var); - let encode_record_fn = Box::new(( - encode_string_fn_var, - Loc::at_zero(encode_string_var), - encode_string_clos_var, - encoder_var, - )); - - // Encode.string s - let encode_string_call = Call( - encode_record_fn, - vec![(Variable::STR, Loc::at_zero(Var(s_sym)))], - CalledVia::Space, - ); - - // Encode.custom \bytes, fmt -> Encode.appendWith bytes (Encode.string s) fmt - let (body, this_encoder_var) = - wrap_in_encode_custom(env, encode_string_call, encoder_var, s_sym, Variable::STR); - - // Create fn_var for ambient capture; we fix it up below. - let fn_var = synth_var(env.subs, Content::Error); - - // -[fn_name]-> - let fn_name_labels = UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![]))); - let fn_clos_var = synth_var( - env.subs, - Content::LambdaSet(LambdaSet { - solved: fn_name_labels, - recursion_var: OptVariable::NONE, - unspecialized: SubsSlice::default(), - ambient_function: fn_var, - }), - ); - // Str -[fn_name]-> (typeof Encode.record [ .. ] = Encoder fmt) - env.subs.set_content( - fn_var, - Content::Structure(FlatType::Func( - string_var_slice, - fn_clos_var, - this_encoder_var, - )), - ); - - // \rcd -[fn_name]-> Encode.record [ { key: .., value: .. }, .. ] - let clos = Closure(ClosureData { - function_type: fn_var, - closure_type: fn_clos_var, - return_type: this_encoder_var, - name: fn_name, - captured_symbols: vec![], - recursive: Recursive::NotRecursive, - arguments: vec![( - Variable::STR, - AnnotatedMark::known_exhaustive(), - Loc::at_zero(Pattern::Identifier(s_sym)), - )], - loc_body: Box::new(Loc::at_zero(body)), - }); - - (clos, fn_var) -} - fn to_encoder_record( env: &mut Env<'_>, record_var: Variable, diff --git a/crates/compiler/derive_key/src/encoding.rs b/crates/compiler/derive_key/src/encoding.rs index b4b92af3bd..33d7d670db 100644 --- a/crates/compiler/derive_key/src/encoding.rs +++ b/crates/compiler/derive_key/src/encoding.rs @@ -14,7 +14,6 @@ pub enum FlatEncodable { #[derive(Hash, PartialEq, Eq, Debug, Clone)] pub enum FlatEncodableKey { - String, List(/* takes one variable */), Set(/* takes one variable */), Dict(/* takes two variables */), @@ -26,7 +25,6 @@ pub enum FlatEncodableKey { impl FlatEncodableKey { pub(crate) fn debug_name(&self) -> String { match self { - FlatEncodableKey::String => "string".to_string(), FlatEncodableKey::List() => "list".to_string(), FlatEncodableKey::Set() => "set".to_string(), FlatEncodableKey::Dict() => "dict".to_string(), @@ -84,7 +82,7 @@ impl FlatEncodable { Symbol::LIST_LIST => Ok(Key(FlatEncodableKey::List())), Symbol::SET_SET => Ok(Key(FlatEncodableKey::Set())), Symbol::DICT_DICT => Ok(Key(FlatEncodableKey::Dict())), - Symbol::STR_STR => Ok(Key(FlatEncodableKey::String)), + Symbol::STR_STR => Ok(Immediate(Symbol::ENCODE_STRING)), _ => Err(Underivable), }, FlatType::Record(fields, ext) => { @@ -134,19 +132,19 @@ impl FlatEncodable { FlatType::Func(..) => Err(Underivable), }, Content::Alias(sym, _, real_var, _) => match sym { - Symbol::NUM_U8 => Ok(Immediate(Symbol::ENCODE_U8)), - Symbol::NUM_U16 => Ok(Immediate(Symbol::ENCODE_U16)), - Symbol::NUM_U32 => Ok(Immediate(Symbol::ENCODE_U32)), - Symbol::NUM_U64 => Ok(Immediate(Symbol::ENCODE_U64)), - Symbol::NUM_U128 => Ok(Immediate(Symbol::ENCODE_U128)), - Symbol::NUM_I8 => Ok(Immediate(Symbol::ENCODE_I8)), - Symbol::NUM_I16 => Ok(Immediate(Symbol::ENCODE_I16)), - Symbol::NUM_I32 => Ok(Immediate(Symbol::ENCODE_I32)), - Symbol::NUM_I64 => Ok(Immediate(Symbol::ENCODE_I64)), - Symbol::NUM_I128 => Ok(Immediate(Symbol::ENCODE_I128)), - Symbol::NUM_DEC => Ok(Immediate(Symbol::ENCODE_DEC)), - Symbol::NUM_F32 => Ok(Immediate(Symbol::ENCODE_F32)), - Symbol::NUM_F64 => Ok(Immediate(Symbol::ENCODE_F64)), + Symbol::NUM_U8 | Symbol::NUM_UNSIGNED8 => Ok(Immediate(Symbol::ENCODE_U8)), + Symbol::NUM_U16 | Symbol::NUM_UNSIGNED16 => Ok(Immediate(Symbol::ENCODE_U16)), + Symbol::NUM_U32 | Symbol::NUM_UNSIGNED32 => Ok(Immediate(Symbol::ENCODE_U32)), + Symbol::NUM_U64 | Symbol::NUM_UNSIGNED64 => Ok(Immediate(Symbol::ENCODE_U64)), + Symbol::NUM_U128 | Symbol::NUM_UNSIGNED128 => Ok(Immediate(Symbol::ENCODE_U128)), + Symbol::NUM_I8 | Symbol::NUM_SIGNED8 => Ok(Immediate(Symbol::ENCODE_I8)), + Symbol::NUM_I16 | Symbol::NUM_SIGNED16 => Ok(Immediate(Symbol::ENCODE_I16)), + Symbol::NUM_I32 | Symbol::NUM_SIGNED32 => Ok(Immediate(Symbol::ENCODE_I32)), + Symbol::NUM_I64 | Symbol::NUM_SIGNED64 => Ok(Immediate(Symbol::ENCODE_I64)), + Symbol::NUM_I128 | Symbol::NUM_SIGNED128 => Ok(Immediate(Symbol::ENCODE_I128)), + Symbol::NUM_DEC | Symbol::NUM_DECIMAL => Ok(Immediate(Symbol::ENCODE_DEC)), + Symbol::NUM_F32 | Symbol::NUM_BINARY32 => Ok(Immediate(Symbol::ENCODE_F32)), + Symbol::NUM_F64 | Symbol::NUM_BINARY64 => Ok(Immediate(Symbol::ENCODE_F64)), // TODO: I believe it is okay to unwrap opaques here because derivers are only used // by the backend, and the backend treats opaques like structural aliases. _ => Self::from_var(subs, real_var), diff --git a/crates/compiler/late_solve/src/lib.rs b/crates/compiler/late_solve/src/lib.rs index ef787ef717..cce4b78fdf 100644 --- a/crates/compiler/late_solve/src/lib.rs +++ b/crates/compiler/late_solve/src/lib.rs @@ -11,7 +11,7 @@ use roc_derive::SharedDerivedModule; use roc_error_macros::internal_error; use roc_module::symbol::ModuleId; use roc_solve::solve::{compact_lambda_sets_of_vars, Phase, Pools}; -use roc_types::subs::{Content, FlatType, LambdaSet}; +use roc_types::subs::{get_member_lambda_sets_at_region, Content, FlatType, LambdaSet}; use roc_types::subs::{ExposedTypesStorageSubs, Subs, Variable}; use roc_unify::unify::{unify as unify_unify, Mode, Unified}; @@ -160,6 +160,86 @@ impl Phase for LatePhase<'_> { } } } + + #[inline(always)] + fn get_and_copy_ability_member_ambient_function( + &self, + ability_member: roc_module::symbol::Symbol, + region: u8, + target_subs: &mut Subs, + ) -> Variable { + match self.abilities { + AbilitiesView::Module(abilities_store) => { + // No option other than that the var must be in our module store. + // Even if the specialization lambda set comes from another module, + // we should have taken care to import it before starting solving in this module. + let member_def = abilities_store + .member_def(ability_member) + .unwrap_or_else(|| { + internal_error!( + "{:?} is not resolved, or not an ability member!", + ability_member + ) + }); + let member_var = member_def.signature_var(); + + let region_lset = get_member_lambda_sets_at_region(target_subs, member_var, region); + + let LambdaSet { + ambient_function, .. + } = target_subs.get_lambda_set(region_lset); + + ambient_function + } + AbilitiesView::World(wa) => { + let member_home = ability_member.module_id(); + let mut world = wa.world.write().unwrap(); + let (module_store, module_types) = world.get_mut(&member_home).unwrap(); + + let member_def = module_store.member_def(ability_member).unwrap_or_else(|| { + internal_error!( + "{:?} is not resolved, or not an ability member!", + ability_member + ) + }); + let member_var = member_def.signature_var(); + let storage_member_var = module_types + .stored_ability_member_vars + .get(&member_var) + .unwrap(); + + let storage_lambda_set_var = get_member_lambda_sets_at_region( + module_types.storage_subs.as_inner(), + *storage_member_var, + region, + ); + + let LambdaSet { + ambient_function, .. + } = module_types + .storage_subs + .as_inner() + .get_lambda_set(storage_lambda_set_var); + + let copied = module_types + .storage_subs + // TODO: I think this is always okay, but revisit later when we're in a more + // stable position to see if we can get rid of the bookkeeping done as a result + // of this. + .export_variable_to_directly_to_use_site(target_subs, ambient_function); + + let our_ambient_function_var = copied.variable; + instantiate_rigids(target_subs, our_ambient_function_var); + + debug_assert!(matches!( + target_subs.get_content_without_compacting(our_ambient_function_var), + Content::Structure(FlatType::Func(..)) + )); + + our_ambient_function_var + } + } + } } /// Unifies two variables and performs lambda set compaction. diff --git a/crates/compiler/load_internal/src/file.rs b/crates/compiler/load_internal/src/file.rs index e168841c9e..11b75f8a20 100644 --- a/crates/compiler/load_internal/src/file.rs +++ b/crates/compiler/load_internal/src/file.rs @@ -4260,9 +4260,11 @@ fn run_solve<'a>( let mut solved_subs = solved_subs; let exposed_types = roc_solve::module::exposed_types_storage_subs( + module_id, &mut solved_subs, &exposed_vars_by_symbol, &solved_specializations, + &abilities_store, ); let solved_module = SolvedModule { diff --git a/crates/compiler/solve/src/ability.rs b/crates/compiler/solve/src/ability.rs index 32340b6ac4..e89cdcec87 100644 --- a/crates/compiler/solve/src/ability.rs +++ b/crates/compiler/solve/src/ability.rs @@ -553,6 +553,34 @@ impl ObligationCache<'_> { } Erroneous(_) => return Err(var), }, + #[rustfmt::skip] + Alias( + Symbol::NUM_U8 | Symbol::NUM_UNSIGNED8 + | Symbol::NUM_U16 | Symbol::NUM_UNSIGNED16 + | Symbol::NUM_U32 | Symbol::NUM_UNSIGNED32 + | Symbol::NUM_U64 | Symbol::NUM_UNSIGNED64 + | Symbol::NUM_U128 | Symbol::NUM_UNSIGNED128 + | Symbol::NUM_I8 | Symbol::NUM_SIGNED8 + | Symbol::NUM_I16 | Symbol::NUM_SIGNED16 + | Symbol::NUM_I32 | Symbol::NUM_SIGNED32 + | Symbol::NUM_I64 | Symbol::NUM_SIGNED64 + | Symbol::NUM_I128 | Symbol::NUM_SIGNED128 + | Symbol::NUM_NAT | Symbol::NUM_NATURAL + | Symbol::NUM_F32 | Symbol::NUM_BINARY32 + | Symbol::NUM_F64 | Symbol::NUM_BINARY64 + | Symbol::NUM_DEC | Symbol::NUM_DECIMAL, + _, + _, + _, + ) => { + // yes + } + Alias( + Symbol::NUM_NUM | Symbol::NUM_INTEGER | Symbol::NUM_FLOATINGPOINT, + _, + real_var, + _, + ) => stack.push(*real_var), Alias(name, _, _, AliasKind::Opaque) => { let opaque = *name; if self @@ -562,27 +590,6 @@ impl ObligationCache<'_> { return Err(var); } } - Alias( - Symbol::NUM_U8 - | Symbol::NUM_U16 - | Symbol::NUM_U32 - | Symbol::NUM_U64 - | Symbol::NUM_U128 - | Symbol::NUM_I8 - | Symbol::NUM_I16 - | Symbol::NUM_I32 - | Symbol::NUM_I64 - | Symbol::NUM_I128 - | Symbol::NUM_NAT - | Symbol::NUM_F32 - | Symbol::NUM_F64 - | Symbol::NUM_DEC, - _, - _, - _, - ) => { - // yes - } Alias(_, arguments, real_type_var, _) => { push_var_slice!(arguments.all_variables()); stack.push(*real_type_var); diff --git a/crates/compiler/solve/src/module.rs b/crates/compiler/solve/src/module.rs index f4194a8b65..f3a437c0e2 100644 --- a/crates/compiler/solve/src/module.rs +++ b/crates/compiler/solve/src/module.rs @@ -105,27 +105,28 @@ pub fn run_solve( /// Copies exposed types and all ability specializations, which may be implicitly exposed. pub fn exposed_types_storage_subs( + home: ModuleId, solved_subs: &mut Solved, exposed_vars_by_symbol: &[(Symbol, Variable)], solved_specializations: &ResolvedSpecializations, + abilities_store: &AbilitiesStore, ) -> ExposedTypesStorageSubs { let subs = solved_subs.inner_mut(); let mut storage_subs = StorageSubs::new(Subs::new()); let mut stored_vars_by_symbol = VecMap::with_capacity(exposed_vars_by_symbol.len()); - let mut stored_specialization_lambda_set_vars = - VecMap::with_capacity(solved_specializations.len()); for (symbol, var) in exposed_vars_by_symbol.iter() { let new_var = storage_subs.import_variable_from(subs, *var).variable; stored_vars_by_symbol.insert(*symbol, new_var); } + let mut stored_specialization_lambda_set_vars = + VecMap::with_capacity(solved_specializations.len()); + for (_, member_specialization) in solved_specializations.iter() { - for (_, &specialization_lset_var) in member_specialization.specialization_lambda_sets.iter() - { - let specialization_lset_ambient_function_var = subs - .get_lambda_set(specialization_lset_var) - .ambient_function; + for (_, &lset_var) in member_specialization.specialization_lambda_sets.iter() { + let specialization_lset_ambient_function_var = + subs.get_lambda_set(lset_var).ambient_function; // Import the ambient function of this specialization lambda set; that will import the // lambda set as well. The ambient function is needed for the lambda set compaction @@ -144,14 +145,29 @@ pub fn exposed_types_storage_subs( roc_types::subs::SubsFmtContent(content, storage_subs.as_inner()) ), }; - stored_specialization_lambda_set_vars - .insert(specialization_lset_var, imported_lset_var); + stored_specialization_lambda_set_vars.insert(lset_var, imported_lset_var); } } + // Store the regioned lambda sets of the ability members defined in this module. + let stored_ability_member_vars = abilities_store + .root_ability_members() + .iter() + .filter_map(|(member, data)| { + if member.module_id() == home { + let var = data.signature_var(); + let imported_var = storage_subs.import_variable_from(subs, var).variable; + Some((var, imported_var)) + } else { + None + } + }) + .collect(); + ExposedTypesStorageSubs { storage_subs, stored_vars_by_symbol, stored_specialization_lambda_set_vars, + stored_ability_member_vars, } } diff --git a/crates/compiler/solve/src/solve.rs b/crates/compiler/solve/src/solve.rs index 9f5459a532..4ab0e6d928 100644 --- a/crates/compiler/solve/src/solve.rs +++ b/crates/compiler/solve/src/solve.rs @@ -22,9 +22,9 @@ use roc_module::symbol::{ModuleId, Symbol}; use roc_problem::can::CycleEntry; use roc_region::all::{Loc, Region}; use roc_types::subs::{ - self, AliasVariables, Content, Descriptor, FlatType, GetSubsSlice, LambdaSet, Mark, - OptVariable, Rank, RecordFields, Subs, SubsIndex, SubsSlice, UlsOfVar, UnionLabels, - UnionLambdas, UnionTags, Variable, VariableSubsSlice, + self, get_member_lambda_sets_at_region, AliasVariables, Content, Descriptor, FlatType, + GetSubsSlice, LambdaSet, Mark, OptVariable, Rank, RecordFields, Subs, SubsIndex, SubsSlice, + UlsOfVar, UnionLabels, UnionLambdas, UnionTags, Variable, VariableSubsSlice, }; use roc_types::types::Type::{self, *}; use roc_types::types::{ @@ -526,6 +526,8 @@ impl Pools { /// What phase in the compiler is reaching out to solve types. /// This is important to distinguish subtle differences in the behavior of the solving algorithm. +// +// TODO the APIs of this trait suck, this needs a nice cleanup. pub trait Phase { /// The regular type-solving phase, or during some later phase of compilation. /// During the solving phase we must anticipate that some information is still unknown and react to @@ -536,12 +538,23 @@ pub trait Phase { where F: FnMut(&AbilitiesStore) -> T; + /// Given a known lambda set's ambient function in an external module, copy that ambient + /// function into the given subs. fn copy_lambda_set_ambient_function_to_home_subs( &self, external_lambda_set_var: Variable, external_module_id: ModuleId, home_subs: &mut Subs, ) -> Variable; + + /// Find the ambient function var at a given region for an ability member definition (not a + /// specialization!), and copy that into the given subs. + fn get_and_copy_ability_member_ambient_function( + &self, + ability_member: Symbol, + region: u8, + home_subs: &mut Subs, + ) -> Variable; } struct SolvePhase<'a> { @@ -572,6 +585,35 @@ impl Phase for SolvePhase<'_> { } = home_subs.get_lambda_set(external_lambda_set_var); ambient_function } + + fn get_and_copy_ability_member_ambient_function( + &self, + ability_member: Symbol, + region: u8, + home_subs: &mut Subs, + ) -> Variable { + // During solving we're only aware of our module's abilities store, the var must + // be in our module store. Even if the specialization lambda set comes from another + // module, we should have taken care to import it before starting solving in this module. + let member_def = self + .abilities_store + .member_def(ability_member) + .unwrap_or_else(|| { + internal_error!( + "{:?} is not resolved, or not an ability member!", + ability_member + ) + }); + let member_var = member_def.signature_var(); + + let region_lset = get_member_lambda_sets_at_region(home_subs, member_var, region); + + let LambdaSet { + ambient_function, .. + } = home_subs.get_lambda_set(region_lset); + + ambient_function + } } #[derive(Clone)] @@ -2179,6 +2221,7 @@ fn compact_lambda_set( enum SpecializationTypeKey { Opaque(Symbol), Derived(DeriveKey), + Immediate(Symbol), } enum SpecializeDecision { @@ -2190,13 +2233,17 @@ fn make_specialization_decision(subs: &Subs, var: Variable) -> SpecializeDecisio use Content::*; use SpecializationTypeKey::*; match subs.get_content_without_compacting(var) { - Structure(_) | Alias(_, _, _, AliasKind::Structural) => { + Alias(opaque, _, _, AliasKind::Opaque) if opaque.module_id() != ModuleId::NUM => { + SpecializeDecision::Specialize(Opaque(*opaque)) + } + Structure(_) | Alias(_, _, _, _) => { // This is a structural type, find the name of the derived ability function it // should use. match roc_derive_key::Derived::encoding(subs, var) { Ok(derived) => match derived { - roc_derive_key::Derived::Immediate(_) => { - todo!("deal with lambda set extraction from immediates") + roc_derive_key::Derived::Immediate(imm) => { + SpecializeDecision::Specialize(Immediate(imm)) + // todo!("deal with lambda set extraction from immediates") } roc_derive_key::Derived::Key(derive_key) => { SpecializeDecision::Specialize(Derived(derive_key)) @@ -2214,7 +2261,6 @@ fn make_specialization_decision(subs: &Subs, var: Variable) -> SpecializeDecisio } } } - Alias(opaque, _, _, AliasKind::Opaque) => SpecializeDecision::Specialize(Opaque(*opaque)), Error => SpecializeDecision::Drop, FlexAbleVar(_, _) | RigidAbleVar(..) @@ -2295,6 +2341,18 @@ fn get_specialization_lambda_set_ambient_function( Ok(specialized_ambient) } + + SpecializationTypeKey::Immediate(imm) => { + // Immediates are like opaques in that we can simply look up their type definition in + // the ability store, there is nothing new to synthesize. + // + // THEORY: if something can become an immediate, it will always be available in the + // local ability store, because the transformation is local (?) + let immediate_lambda_set_at_region = + phase.get_and_copy_ability_member_ambient_function(imm, lset_region, subs); + + Ok(immediate_lambda_set_at_region) + } } } diff --git a/crates/compiler/test_derive/src/encoding.rs b/crates/compiler/test_derive/src/encoding.rs index 1d1d4fcb2b..383a7e641d 100644 --- a/crates/compiler/test_derive/src/encoding.rs +++ b/crates/compiler/test_derive/src/encoding.rs @@ -515,25 +515,7 @@ fn immediates() { check_immediate(v!(DEC), Symbol::ENCODE_DEC); check_immediate(v!(F32), Symbol::ENCODE_F32); check_immediate(v!(F64), Symbol::ENCODE_F64); -} - -#[test] -fn string() { - derive_test(v!(STR), |golden| { - assert_snapshot!(golden, @r###" - # derived for Str - # Str -[[toEncoder_string(0)]]-> Encoder fmt | fmt has EncoderFormatting - # Str -[[toEncoder_string(0)]]-> (List U8, fmt -[[custom(2) Str]]-> List U8) | fmt has EncoderFormatting - # Specialization lambda sets: - # @<1>: [[toEncoder_string(0)]] - # @<2>: [[custom(2) Str]] - #Derived.toEncoder_string = - \#Derived.s -> - Encode.custom \#Derived.bytes, #Derived.fmt -> - Encode.appendWith #Derived.bytes (Encode.string #Derived.s) #Derived.fmt - "### - ) - }) + check_immediate(v!(STR), Symbol::ENCODE_STRING); } #[test] diff --git a/crates/compiler/test_gen/src/gen_abilities.rs b/crates/compiler/test_gen/src/gen_abilities.rs index 4d8ed837cd..fa9a735386 100644 --- a/crates/compiler/test_gen/src/gen_abilities.rs +++ b/crates/compiler/test_gen/src/gen_abilities.rs @@ -404,26 +404,73 @@ fn to_encoder_encode_custom_has_capture() { ) } -#[test] -#[cfg(any(feature = "gen-llvm"))] -fn encode_derived_string() { - assert_evals_to!( - indoc!( - r#" - app "test" - imports [Encode.{ toEncoder }, Json] - provides [main] to "./platform" +mod encode_immediate { + #[cfg(feature = "gen-llvm")] + use crate::helpers::llvm::assert_evals_to; - main = - result = Str.fromUtf8 (Encode.toBytes "foo" Json.format) - when result is - Ok s -> s - _ -> "" - "# - ), - RocStr::from("\"foo\""), - RocStr - ) + #[cfg(all(test, any(feature = "gen-llvm", feature = "gen-wasm")))] + use indoc::indoc; + + #[cfg(all(test, any(feature = "gen-llvm", feature = "gen-wasm")))] + use roc_std::RocStr; + + #[test] + #[cfg(any(feature = "gen-llvm"))] + fn string() { + assert_evals_to!( + indoc!( + r#" + app "test" imports [Encode.{ toEncoder }, Json] provides [main] to "./platform" + + main = + when Str.fromUtf8 (Encode.toBytes "foo" Json.format) is + Ok s -> s + _ -> "" + "# + ), + RocStr::from("\"foo\""), + RocStr + ) + } + + macro_rules! num_immediate { + ($($num:expr, $typ:ident)*) => {$( + #[test] + #[cfg(any(feature = "gen-llvm"))] + fn $typ() { + assert_evals_to!( + &format!(indoc!( + r#" + app "test" imports [Encode.{{ toEncoder }}, Json] provides [main] to "./platform" + + main = + when Str.fromUtf8 (Encode.toBytes {}{} Json.format) is + Ok s -> s + _ -> "" + "# + ), $num, stringify!($typ)), + RocStr::from(format!(r#"{}"#, $num).as_str()), + RocStr + ) + } + )*} + } + + num_immediate! { + 17, i8 + 17, i16 + 17, i32 + 17, i64 + 17, i128 + 17, u8 + 17, u16 + 17, u32 + 17, u64 + 17, u128 + // 17.23, f32 TODO https://github.com/rtfeldman/roc/issues/3522 + 17.23, f64 + // 17.23, dec TODO https://github.com/rtfeldman/roc/issues/3522 + } } #[test] diff --git a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt index 9600443988..6182bbb065 100644 --- a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt @@ -3,19 +3,6 @@ procedure #Derived.0 (#Derived.1): let #Derived_gen.0 : {Str} = CallByName Encode.22 #Derived_gen.1; ret #Derived_gen.0; -procedure #Derived.10 (#Derived.11): - let #Derived_gen.29 : {Str} = Struct {#Derived.11}; - let #Derived_gen.28 : {Str} = CallByName Encode.22 #Derived_gen.29; - ret #Derived_gen.28; - -procedure #Derived.12 (#Derived.13, #Derived.14, #Attr.12): - let #Derived.11 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.11; - dec #Attr.12; - let #Derived_gen.32 : {Str} = CallByName Json.17 #Derived.11; - let #Derived_gen.31 : List U8 = CallByName Encode.23 #Derived.13 #Derived_gen.32 #Derived.14; - ret #Derived_gen.31; - procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12): let #Derived.1 : Str = StructAtIndex 0 #Attr.12; inc #Derived.1; @@ -38,7 +25,7 @@ procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12): inc #Derived.6; dec #Attr.12; let #Derived_gen.21 : Str = "b"; - let #Derived_gen.22 : {Str} = CallByName #Derived.10 #Derived.6; + let #Derived_gen.22 : {Str} = CallByName Json.17 #Derived.6; let #Derived_gen.20 : {Str, {Str}} = Struct {#Derived_gen.21, #Derived_gen.22}; let #Derived_gen.19 : List {Str, {Str}} = Array [#Derived_gen.20]; let #Derived_gen.18 : {List {Str, {Str}}} = CallByName Json.19 #Derived_gen.19; @@ -60,9 +47,6 @@ procedure Encode.22 (Encode.93): procedure Encode.22 (Encode.93): ret Encode.93; -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.23 (Encode.94, Encode.102, Encode.96): let Encode.106 : List U8 = CallByName #Derived.2 Encode.94 Encode.96 Encode.102; ret Encode.106; @@ -80,12 +64,8 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96): ret Encode.125; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.127 : List U8 = CallByName #Derived.12 Encode.94 Encode.96 Encode.102; - ret Encode.127; - -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.137 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.137; + let Encode.128 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; + ret Encode.128; procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; @@ -98,9 +78,9 @@ procedure Json.1 (): ret Json.102; procedure Json.17 (Json.64): - let Json.186 : {Str} = Struct {Json.64}; - let Json.185 : {Str} = CallByName Encode.22 Json.186; - ret Json.185; + let Json.149 : {Str} = Struct {Json.64}; + let Json.148 : {Str} = CallByName Encode.22 Json.149; + ret Json.148; procedure Json.19 (Json.76): let Json.104 : {List {Str, {Str}}} = Struct {Json.76}; @@ -112,19 +92,19 @@ procedure Json.19 (Json.76): let Json.145 : {List {Str, {Str}}} = CallByName Encode.22 Json.146; ret Json.145; -procedure Json.65 (Json.66, Json.187, #Attr.12): +procedure Json.65 (Json.66, Json.150, #Attr.12): let Json.64 : Str = StructAtIndex 0 #Attr.12; inc Json.64; dec #Attr.12; - let Json.196 : I32 = 34i64; - let Json.195 : U8 = CallByName Num.123 Json.196; - let Json.193 : List U8 = CallByName List.4 Json.66 Json.195; - let Json.194 : List U8 = CallByName Str.12 Json.64; - let Json.190 : List U8 = CallByName List.8 Json.193 Json.194; - let Json.192 : I32 = 34i64; - let Json.191 : U8 = CallByName Num.123 Json.192; - let Json.189 : List U8 = CallByName List.4 Json.190 Json.191; - ret Json.189; + let Json.190 : I32 = 34i64; + let Json.189 : U8 = CallByName Num.123 Json.190; + let Json.187 : List U8 = CallByName List.4 Json.66 Json.189; + let Json.188 : List U8 = CallByName Str.12 Json.64; + let Json.184 : List U8 = CallByName List.8 Json.187 Json.188; + let Json.186 : I32 = 34i64; + let Json.185 : U8 = CallByName Num.123 Json.186; + let Json.183 : List U8 = CallByName List.4 Json.184 Json.185; + ret Json.183; procedure Json.77 (Json.78, Json.105, #Attr.12): let Json.76 : List {Str, {Str}} = StructAtIndex 0 #Attr.12; @@ -150,21 +130,21 @@ procedure Json.77 (Json.78, Json.105, #Attr.12): let Json.76 : List {Str, {Str}} = StructAtIndex 0 #Attr.12; inc Json.76; dec #Attr.12; - let Json.178 : I32 = 123i64; - let Json.177 : U8 = CallByName Num.123 Json.178; - let Json.80 : List U8 = CallByName List.4 Json.78 Json.177; - let Json.176 : U64 = CallByName List.6 Json.76; - let Json.153 : {List U8, U64} = Struct {Json.80, Json.176}; - let Json.154 : {} = Struct {}; - let Json.152 : {List U8, U64} = CallByName List.18 Json.76 Json.153 Json.154; + let Json.181 : I32 = 123i64; + let Json.180 : U8 = CallByName Num.123 Json.181; + let Json.80 : List U8 = CallByName List.4 Json.78 Json.180; + let Json.179 : U64 = CallByName List.6 Json.76; + let Json.156 : {List U8, U64} = Struct {Json.80, Json.179}; + let Json.157 : {} = Struct {}; + let Json.155 : {List U8, U64} = CallByName List.18 Json.76 Json.156 Json.157; dec Json.76; - let Json.82 : List U8 = StructAtIndex 0 Json.152; + let Json.82 : List U8 = StructAtIndex 0 Json.155; inc Json.82; - dec Json.152; - let Json.151 : I32 = 125i64; - let Json.150 : U8 = CallByName Num.123 Json.151; - let Json.149 : List U8 = CallByName List.4 Json.82 Json.150; - ret Json.149; + dec Json.155; + let Json.154 : I32 = 125i64; + let Json.153 : U8 = CallByName Num.123 Json.154; + let Json.152 : List U8 = CallByName List.4 Json.82 Json.153; + ret Json.152; procedure Json.79 (Json.107, Json.108): let Json.85 : Str = StructAtIndex 0 Json.108; @@ -215,34 +195,34 @@ procedure Json.79 (Json.107, Json.108): inc Json.83; let Json.84 : U64 = StructAtIndex 1 Json.107; dec Json.107; - let Json.175 : I32 = 34i64; - let Json.174 : U8 = CallByName Num.123 Json.175; - let Json.172 : List U8 = CallByName List.4 Json.83 Json.174; - let Json.173 : List U8 = CallByName Str.12 Json.85; - let Json.169 : List U8 = CallByName List.8 Json.172 Json.173; - let Json.171 : I32 = 34i64; + let Json.178 : I32 = 34i64; + let Json.177 : U8 = CallByName Num.123 Json.178; + let Json.175 : List U8 = CallByName List.4 Json.83 Json.177; + let Json.176 : List U8 = CallByName Str.12 Json.85; + let Json.172 : List U8 = CallByName List.8 Json.175 Json.176; + let Json.174 : I32 = 34i64; + let Json.173 : U8 = CallByName Num.123 Json.174; + let Json.169 : List U8 = CallByName List.4 Json.172 Json.173; + let Json.171 : I32 = 58i64; let Json.170 : U8 = CallByName Num.123 Json.171; - let Json.166 : List U8 = CallByName List.4 Json.169 Json.170; - let Json.168 : I32 = 58i64; - let Json.167 : U8 = CallByName Num.123 Json.168; - let Json.164 : List U8 = CallByName List.4 Json.166 Json.167; - let Json.165 : {} = Struct {}; - let Json.87 : List U8 = CallByName Encode.23 Json.164 Json.86 Json.165; - joinpoint Json.159 Json.88: - let Json.157 : U64 = 1i64; - let Json.156 : U64 = CallByName Num.20 Json.84 Json.157; - let Json.155 : {List U8, U64} = Struct {Json.88, Json.156}; - ret Json.155; + let Json.167 : List U8 = CallByName List.4 Json.169 Json.170; + let Json.168 : {} = Struct {}; + let Json.87 : List U8 = CallByName Encode.23 Json.167 Json.86 Json.168; + joinpoint Json.162 Json.88: + let Json.160 : U64 = 1i64; + let Json.159 : U64 = CallByName Num.20 Json.84 Json.160; + let Json.158 : {List U8, U64} = Struct {Json.88, Json.159}; + ret Json.158; in - let Json.163 : U64 = 0i64; - let Json.160 : Int1 = CallByName Num.24 Json.84 Json.163; - if Json.160 then - let Json.162 : I32 = 44i64; - let Json.161 : U8 = CallByName Num.123 Json.162; - let Json.158 : List U8 = CallByName List.4 Json.87 Json.161; - jump Json.159 Json.158; + let Json.166 : U64 = 0i64; + let Json.163 : Int1 = CallByName Num.24 Json.84 Json.166; + if Json.163 then + let Json.165 : I32 = 44i64; + let Json.164 : U8 = CallByName Num.123 Json.165; + let Json.161 : List U8 = CallByName List.4 Json.87 Json.164; + jump Json.162 Json.161; else - jump Json.159 Json.87; + jump Json.162 Json.87; procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; @@ -252,9 +232,9 @@ procedure List.122 (List.123, List.124, #Attr.12): procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; - let List.418 : {List U8, U64} = CallByName Json.79 List.123 List.124; - let List.417 : [C [], C {List U8, U64}] = TagId(1) List.418; - ret List.417; + let List.425 : {List U8, U64} = CallByName Json.79 List.123 List.124; + let List.424 : [C [], C {List U8, U64}] = TagId(1) List.425; + ret List.424; procedure List.18 (List.119, List.120, List.121): let List.321 : {{}} = Struct {List.121}; @@ -274,27 +254,27 @@ procedure List.18 (List.119, List.120, List.121): ret List.317; procedure List.18 (List.119, List.120, List.121): - let List.395 : {{}} = Struct {List.121}; - let List.389 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.395; - let List.392 : U8 = 1i64; - let List.393 : U8 = GetTagId List.389; - let List.394 : Int1 = lowlevel Eq List.392 List.393; - if List.394 then - let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.389; + let List.401 : {{}} = Struct {List.121}; + let List.395 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.401; + let List.398 : U8 = 1i64; + let List.399 : U8 = GetTagId List.395; + let List.400 : Int1 = lowlevel Eq List.398 List.399; + if List.400 then + let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.395; inc List.126; - dec List.389; + dec List.395; ret List.126; else - let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.389; - dec List.389; - let List.391 : {List U8, U64} = CallByName List.64 List.127; - ret List.391; + let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.395; + dec List.395; + let List.397 : {List U8, U64} = CallByName List.64 List.127; + ret List.397; procedure List.4 (List.90, List.91): - let List.450 : U64 = 1i64; - let List.449 : List U8 = CallByName List.65 List.90 List.450; - let List.448 : List U8 = CallByName List.66 List.449 List.91; - ret List.448; + let List.394 : U64 = 1i64; + let List.393 : List U8 = CallByName List.65 List.90 List.394; + let List.392 : List U8 = CallByName List.66 List.393 List.91; + ret List.392; procedure List.6 (#Attr.2): let List.295 : U64 = lowlevel ListLen #Attr.2; @@ -305,16 +285,16 @@ procedure List.6 (#Attr.2): ret List.323; procedure List.6 (#Attr.2): - let List.397 : U64 = lowlevel ListLen #Attr.2; - ret List.397; + let List.404 : U64 = lowlevel ListLen #Attr.2; + ret List.404; procedure List.60 (#Attr.2, #Attr.3): let List.342 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; ret List.342; procedure List.60 (#Attr.2, #Attr.3): - let List.416 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.416; + let List.423 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.423; procedure List.63 (List.283, List.284, List.285): let List.328 : U64 = 0i64; @@ -323,22 +303,22 @@ procedure List.63 (List.283, List.284, List.285): ret List.327; procedure List.63 (List.283, List.284, List.285): - let List.402 : U64 = 0i64; - let List.403 : U64 = CallByName List.6 List.283; - let List.401 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.402 List.403; - ret List.401; + let List.409 : U64 = 0i64; + let List.410 : U64 = CallByName List.6 List.283; + let List.408 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.409 List.410; + ret List.408; procedure List.64 (#Attr.2): - let List.400 : {List U8, U64} = lowlevel Unreachable #Attr.2; - ret List.400; + let List.407 : {List U8, U64} = lowlevel Unreachable #Attr.2; + ret List.407; procedure List.65 (#Attr.2, #Attr.3): - let List.453 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.453; + let List.406 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.406; procedure List.66 (#Attr.2, #Attr.3): - let List.452 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.452; + let List.405 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.405; procedure List.77 (List.361, List.362, List.363, List.364, List.365): joinpoint List.330 List.286 List.287 List.288 List.289 List.290: @@ -367,60 +347,60 @@ procedure List.77 (List.361, List.362, List.363, List.364, List.365): in jump List.330 List.361 List.362 List.363 List.364 List.365; -procedure List.77 (List.435, List.436, List.437, List.438, List.439): - joinpoint List.404 List.286 List.287 List.288 List.289 List.290: - let List.406 : Int1 = CallByName Num.22 List.289 List.290; - if List.406 then - let List.415 : {Str, {Str}} = CallByName List.60 List.286 List.289; - let List.407 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.415 List.288; - let List.412 : U8 = 1i64; - let List.413 : U8 = GetTagId List.407; - let List.414 : Int1 = lowlevel Eq List.412 List.413; - if List.414 then - let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.407; +procedure List.77 (List.442, List.443, List.444, List.445, List.446): + joinpoint List.411 List.286 List.287 List.288 List.289 List.290: + let List.413 : Int1 = CallByName Num.22 List.289 List.290; + if List.413 then + let List.422 : {Str, {Str}} = CallByName List.60 List.286 List.289; + let List.414 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.422 List.288; + let List.419 : U8 = 1i64; + let List.420 : U8 = GetTagId List.414; + let List.421 : Int1 = lowlevel Eq List.419 List.420; + if List.421 then + let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.414; inc List.291; - dec List.407; - let List.410 : U64 = 1i64; - let List.409 : U64 = CallByName Num.19 List.289 List.410; - jump List.404 List.286 List.291 List.288 List.409 List.290; + dec List.414; + let List.417 : U64 = 1i64; + let List.416 : U64 = CallByName Num.19 List.289 List.417; + jump List.411 List.286 List.291 List.288 List.416 List.290; else - let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.407; - dec List.407; - let List.411 : [C [], C {List U8, U64}] = TagId(0) List.292; - ret List.411; + let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.414; + dec List.414; + let List.418 : [C [], C {List U8, U64}] = TagId(0) List.292; + ret List.418; else - let List.405 : [C [], C {List U8, U64}] = TagId(1) List.287; - ret List.405; + let List.412 : [C [], C {List U8, U64}] = TagId(1) List.287; + ret List.412; in - jump List.404 List.435 List.436 List.437 List.438 List.439; + jump List.411 List.442 List.443 List.444 List.445 List.446; procedure List.8 (#Attr.2, #Attr.3): - let List.451 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.451; + let List.403 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.403; procedure Num.123 (#Attr.2): - let Num.296 : U8 = lowlevel NumIntCast #Attr.2; - ret Num.296; - -procedure Num.19 (#Attr.2, #Attr.3): - let Num.284 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.284; - -procedure Num.20 (#Attr.2, #Attr.3): - let Num.282 : U64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.282; - -procedure Num.22 (#Attr.2, #Attr.3): - let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.285; - -procedure Num.24 (#Attr.2, #Attr.3): - let Num.283 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + let Num.283 : U8 = lowlevel NumIntCast #Attr.2; ret Num.283; +procedure Num.19 (#Attr.2, #Attr.3): + let Num.286 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.286; + +procedure Num.20 (#Attr.2, #Attr.3): + let Num.284 : U64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.284; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.287 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.287; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.285 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.285; + procedure Str.12 (#Attr.2): - let Str.213 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.213; + let Str.212 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.212; procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; diff --git a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt index fb6719984c..af9fddf50a 100644 --- a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt @@ -8,29 +8,13 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12): inc #Derived.1; dec #Attr.12; let #Derived_gen.7 : Str = "a"; - let #Derived_gen.8 : {Str} = CallByName #Derived.5 #Derived.1; + let #Derived_gen.8 : {Str} = CallByName Json.17 #Derived.1; let #Derived_gen.6 : {Str, {Str}} = Struct {#Derived_gen.7, #Derived_gen.8}; let #Derived_gen.5 : List {Str, {Str}} = Array [#Derived_gen.6]; let #Derived_gen.4 : {List {Str, {Str}}} = CallByName Json.19 #Derived_gen.5; let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4; ret #Derived_gen.3; -procedure #Derived.5 (#Derived.6): - let #Derived_gen.15 : {Str} = Struct {#Derived.6}; - let #Derived_gen.14 : {Str} = CallByName Encode.22 #Derived_gen.15; - ret #Derived_gen.14; - -procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12): - let #Derived.6 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.6; - dec #Attr.12; - let #Derived_gen.18 : {Str} = CallByName Json.17 #Derived.6; - let #Derived_gen.17 : List U8 = CallByName Encode.23 #Derived.8 #Derived_gen.18 #Derived.9; - ret #Derived_gen.17; - -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.22 (Encode.93): ret Encode.93; @@ -49,12 +33,8 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96): ret Encode.113; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.115 : List U8 = CallByName #Derived.7 Encode.94 Encode.96 Encode.102; - ret Encode.115; - -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.125 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.125; + let Encode.116 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; + ret Encode.116; procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; @@ -67,201 +47,201 @@ procedure Json.1 (): ret Json.102; procedure Json.17 (Json.64): - let Json.146 : {Str} = Struct {Json.64}; - let Json.145 : {Str} = CallByName Encode.22 Json.146; - ret Json.145; + let Json.107 : {Str} = Struct {Json.64}; + let Json.106 : {Str} = CallByName Encode.22 Json.107; + ret Json.106; procedure Json.19 (Json.76): let Json.104 : {List {Str, {Str}}} = Struct {Json.76}; let Json.103 : {List {Str, {Str}}} = CallByName Encode.22 Json.104; ret Json.103; -procedure Json.65 (Json.66, Json.147, #Attr.12): +procedure Json.65 (Json.66, Json.108, #Attr.12): let Json.64 : Str = StructAtIndex 0 #Attr.12; inc Json.64; dec #Attr.12; - let Json.156 : I32 = 34i64; - let Json.155 : U8 = CallByName Num.123 Json.156; - let Json.153 : List U8 = CallByName List.4 Json.66 Json.155; - let Json.154 : List U8 = CallByName Str.12 Json.64; - let Json.150 : List U8 = CallByName List.8 Json.153 Json.154; - let Json.152 : I32 = 34i64; - let Json.151 : U8 = CallByName Num.123 Json.152; - let Json.149 : List U8 = CallByName List.4 Json.150 Json.151; - ret Json.149; + let Json.150 : I32 = 34i64; + let Json.149 : U8 = CallByName Num.123 Json.150; + let Json.147 : List U8 = CallByName List.4 Json.66 Json.149; + let Json.148 : List U8 = CallByName Str.12 Json.64; + let Json.144 : List U8 = CallByName List.8 Json.147 Json.148; + let Json.146 : I32 = 34i64; + let Json.145 : U8 = CallByName Num.123 Json.146; + let Json.143 : List U8 = CallByName List.4 Json.144 Json.145; + ret Json.143; procedure Json.77 (Json.78, Json.105, #Attr.12): let Json.76 : List {Str, {Str}} = StructAtIndex 0 #Attr.12; inc Json.76; dec #Attr.12; - let Json.138 : I32 = 123i64; - let Json.137 : U8 = CallByName Num.123 Json.138; - let Json.80 : List U8 = CallByName List.4 Json.78 Json.137; - let Json.136 : U64 = CallByName List.6 Json.76; - let Json.113 : {List U8, U64} = Struct {Json.80, Json.136}; - let Json.114 : {} = Struct {}; - let Json.112 : {List U8, U64} = CallByName List.18 Json.76 Json.113 Json.114; + let Json.141 : I32 = 123i64; + let Json.140 : U8 = CallByName Num.123 Json.141; + let Json.80 : List U8 = CallByName List.4 Json.78 Json.140; + let Json.139 : U64 = CallByName List.6 Json.76; + let Json.116 : {List U8, U64} = Struct {Json.80, Json.139}; + let Json.117 : {} = Struct {}; + let Json.115 : {List U8, U64} = CallByName List.18 Json.76 Json.116 Json.117; dec Json.76; - let Json.82 : List U8 = StructAtIndex 0 Json.112; + let Json.82 : List U8 = StructAtIndex 0 Json.115; inc Json.82; - dec Json.112; - let Json.111 : I32 = 125i64; - let Json.110 : U8 = CallByName Num.123 Json.111; - let Json.109 : List U8 = CallByName List.4 Json.82 Json.110; - ret Json.109; + dec Json.115; + let Json.114 : I32 = 125i64; + let Json.113 : U8 = CallByName Num.123 Json.114; + let Json.112 : List U8 = CallByName List.4 Json.82 Json.113; + ret Json.112; -procedure Json.79 (Json.107, Json.108): - let Json.85 : Str = StructAtIndex 0 Json.108; +procedure Json.79 (Json.110, Json.111): + let Json.85 : Str = StructAtIndex 0 Json.111; inc Json.85; - let Json.86 : {Str} = StructAtIndex 1 Json.108; + let Json.86 : {Str} = StructAtIndex 1 Json.111; inc Json.86; - dec Json.108; - let Json.83 : List U8 = StructAtIndex 0 Json.107; + dec Json.111; + let Json.83 : List U8 = StructAtIndex 0 Json.110; inc Json.83; - let Json.84 : U64 = StructAtIndex 1 Json.107; - dec Json.107; - let Json.135 : I32 = 34i64; - let Json.134 : U8 = CallByName Num.123 Json.135; - let Json.132 : List U8 = CallByName List.4 Json.83 Json.134; - let Json.133 : List U8 = CallByName Str.12 Json.85; - let Json.129 : List U8 = CallByName List.8 Json.132 Json.133; - let Json.131 : I32 = 34i64; + let Json.84 : U64 = StructAtIndex 1 Json.110; + dec Json.110; + let Json.138 : I32 = 34i64; + let Json.137 : U8 = CallByName Num.123 Json.138; + let Json.135 : List U8 = CallByName List.4 Json.83 Json.137; + let Json.136 : List U8 = CallByName Str.12 Json.85; + let Json.132 : List U8 = CallByName List.8 Json.135 Json.136; + let Json.134 : I32 = 34i64; + let Json.133 : U8 = CallByName Num.123 Json.134; + let Json.129 : List U8 = CallByName List.4 Json.132 Json.133; + let Json.131 : I32 = 58i64; let Json.130 : U8 = CallByName Num.123 Json.131; - let Json.126 : List U8 = CallByName List.4 Json.129 Json.130; - let Json.128 : I32 = 58i64; - let Json.127 : U8 = CallByName Num.123 Json.128; - let Json.124 : List U8 = CallByName List.4 Json.126 Json.127; - let Json.125 : {} = Struct {}; - let Json.87 : List U8 = CallByName Encode.23 Json.124 Json.86 Json.125; - joinpoint Json.119 Json.88: - let Json.117 : U64 = 1i64; - let Json.116 : U64 = CallByName Num.20 Json.84 Json.117; - let Json.115 : {List U8, U64} = Struct {Json.88, Json.116}; - ret Json.115; + let Json.127 : List U8 = CallByName List.4 Json.129 Json.130; + let Json.128 : {} = Struct {}; + let Json.87 : List U8 = CallByName Encode.23 Json.127 Json.86 Json.128; + joinpoint Json.122 Json.88: + let Json.120 : U64 = 1i64; + let Json.119 : U64 = CallByName Num.20 Json.84 Json.120; + let Json.118 : {List U8, U64} = Struct {Json.88, Json.119}; + ret Json.118; in - let Json.123 : U64 = 0i64; - let Json.120 : Int1 = CallByName Num.24 Json.84 Json.123; - if Json.120 then - let Json.122 : I32 = 44i64; - let Json.121 : U8 = CallByName Num.123 Json.122; - let Json.118 : List U8 = CallByName List.4 Json.87 Json.121; - jump Json.119 Json.118; + let Json.126 : U64 = 0i64; + let Json.123 : Int1 = CallByName Num.24 Json.84 Json.126; + if Json.123 then + let Json.125 : I32 = 44i64; + let Json.124 : U8 = CallByName Num.123 Json.125; + let Json.121 : List U8 = CallByName List.4 Json.87 Json.124; + jump Json.122 Json.121; else - jump Json.119 Json.87; + jump Json.122 Json.87; procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; - let List.344 : {List U8, U64} = CallByName Json.79 List.123 List.124; - let List.343 : [C [], C {List U8, U64}] = TagId(1) List.344; - ret List.343; + let List.351 : {List U8, U64} = CallByName Json.79 List.123 List.124; + let List.350 : [C [], C {List U8, U64}] = TagId(1) List.351; + ret List.350; procedure List.18 (List.119, List.120, List.121): - let List.321 : {{}} = Struct {List.121}; - let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.321; - let List.318 : U8 = 1i64; - let List.319 : U8 = GetTagId List.315; - let List.320 : Int1 = lowlevel Eq List.318 List.319; - if List.320 then - let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315; + let List.327 : {{}} = Struct {List.121}; + let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327; + let List.324 : U8 = 1i64; + let List.325 : U8 = GetTagId List.321; + let List.326 : Int1 = lowlevel Eq List.324 List.325; + if List.326 then + let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321; inc List.126; - dec List.315; + dec List.321; ret List.126; else - let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.315; - dec List.315; - let List.317 : {List U8, U64} = CallByName List.64 List.127; - ret List.317; + let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321; + dec List.321; + let List.323 : {List U8, U64} = CallByName List.64 List.127; + ret List.323; procedure List.4 (List.90, List.91): - let List.376 : U64 = 1i64; - let List.375 : List U8 = CallByName List.65 List.90 List.376; - let List.374 : List U8 = CallByName List.66 List.375 List.91; - ret List.374; + let List.320 : U64 = 1i64; + let List.319 : List U8 = CallByName List.65 List.90 List.320; + let List.318 : List U8 = CallByName List.66 List.319 List.91; + ret List.318; procedure List.6 (#Attr.2): let List.295 : U64 = lowlevel ListLen #Attr.2; ret List.295; procedure List.6 (#Attr.2): - let List.323 : U64 = lowlevel ListLen #Attr.2; - ret List.323; + let List.330 : U64 = lowlevel ListLen #Attr.2; + ret List.330; procedure List.60 (#Attr.2, #Attr.3): - let List.342 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.342; + let List.349 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.349; procedure List.63 (List.283, List.284, List.285): - let List.328 : U64 = 0i64; - let List.329 : U64 = CallByName List.6 List.283; - let List.327 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.328 List.329; - ret List.327; + let List.335 : U64 = 0i64; + let List.336 : U64 = CallByName List.6 List.283; + let List.334 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.335 List.336; + ret List.334; procedure List.64 (#Attr.2): - let List.326 : {List U8, U64} = lowlevel Unreachable #Attr.2; - ret List.326; + let List.333 : {List U8, U64} = lowlevel Unreachable #Attr.2; + ret List.333; procedure List.65 (#Attr.2, #Attr.3): - let List.379 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.379; + let List.332 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.332; procedure List.66 (#Attr.2, #Attr.3): - let List.378 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.378; + let List.331 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.331; -procedure List.77 (List.361, List.362, List.363, List.364, List.365): - joinpoint List.330 List.286 List.287 List.288 List.289 List.290: - let List.332 : Int1 = CallByName Num.22 List.289 List.290; - if List.332 then - let List.341 : {Str, {Str}} = CallByName List.60 List.286 List.289; - let List.333 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.341 List.288; - let List.338 : U8 = 1i64; - let List.339 : U8 = GetTagId List.333; - let List.340 : Int1 = lowlevel Eq List.338 List.339; - if List.340 then - let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.333; +procedure List.77 (List.368, List.369, List.370, List.371, List.372): + joinpoint List.337 List.286 List.287 List.288 List.289 List.290: + let List.339 : Int1 = CallByName Num.22 List.289 List.290; + if List.339 then + let List.348 : {Str, {Str}} = CallByName List.60 List.286 List.289; + let List.340 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.348 List.288; + let List.345 : U8 = 1i64; + let List.346 : U8 = GetTagId List.340; + let List.347 : Int1 = lowlevel Eq List.345 List.346; + if List.347 then + let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.340; inc List.291; - dec List.333; - let List.336 : U64 = 1i64; - let List.335 : U64 = CallByName Num.19 List.289 List.336; - jump List.330 List.286 List.291 List.288 List.335 List.290; + dec List.340; + let List.343 : U64 = 1i64; + let List.342 : U64 = CallByName Num.19 List.289 List.343; + jump List.337 List.286 List.291 List.288 List.342 List.290; else - let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.333; - dec List.333; - let List.337 : [C [], C {List U8, U64}] = TagId(0) List.292; - ret List.337; + let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.340; + dec List.340; + let List.344 : [C [], C {List U8, U64}] = TagId(0) List.292; + ret List.344; else - let List.331 : [C [], C {List U8, U64}] = TagId(1) List.287; - ret List.331; + let List.338 : [C [], C {List U8, U64}] = TagId(1) List.287; + ret List.338; in - jump List.330 List.361 List.362 List.363 List.364 List.365; + jump List.337 List.368 List.369 List.370 List.371 List.372; procedure List.8 (#Attr.2, #Attr.3): - let List.377 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.377; + let List.329 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.329; procedure Num.123 (#Attr.2): - let Num.277 : U8 = lowlevel NumIntCast #Attr.2; - ret Num.277; - -procedure Num.19 (#Attr.2, #Attr.3): - let Num.265 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.265; - -procedure Num.20 (#Attr.2, #Attr.3): - let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.263; - -procedure Num.22 (#Attr.2, #Attr.3): - let Num.266 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.266; - -procedure Num.24 (#Attr.2, #Attr.3): - let Num.264 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + let Num.264 : U8 = lowlevel NumIntCast #Attr.2; ret Num.264; +procedure Num.19 (#Attr.2, #Attr.3): + let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.267; + +procedure Num.20 (#Attr.2, #Attr.3): + let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.265; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.268; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.266; + procedure Str.12 (#Attr.2): - let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.211; + let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.210; procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; diff --git a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt index 4dcea35347..b27d827bd9 100644 --- a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt +++ b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt @@ -10,35 +10,19 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12): let #Derived_gen.11 : Str = "a"; let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1; inc #Derived_gen.13; - let #Derived_gen.12 : {Str} = CallByName #Derived.5 #Derived_gen.13; + let #Derived_gen.12 : {Str} = CallByName Json.17 #Derived_gen.13; let #Derived_gen.6 : {Str, {Str}} = Struct {#Derived_gen.11, #Derived_gen.12}; let #Derived_gen.8 : Str = "b"; let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1; inc #Derived_gen.10; dec #Derived.1; - let #Derived_gen.9 : {Str} = CallByName #Derived.5 #Derived_gen.10; + let #Derived_gen.9 : {Str} = CallByName Json.17 #Derived_gen.10; let #Derived_gen.7 : {Str, {Str}} = Struct {#Derived_gen.8, #Derived_gen.9}; let #Derived_gen.5 : List {Str, {Str}} = Array [#Derived_gen.6, #Derived_gen.7]; let #Derived_gen.4 : {List {Str, {Str}}} = CallByName Json.19 #Derived_gen.5; let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4; ret #Derived_gen.3; -procedure #Derived.5 (#Derived.6): - let #Derived_gen.21 : {Str} = Struct {#Derived.6}; - let #Derived_gen.20 : {Str} = CallByName Encode.22 #Derived_gen.21; - ret #Derived_gen.20; - -procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12): - let #Derived.6 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.6; - dec #Attr.12; - let #Derived_gen.24 : {Str} = CallByName Json.17 #Derived.6; - let #Derived_gen.23 : List U8 = CallByName Encode.23 #Derived.8 #Derived_gen.24 #Derived.9; - ret #Derived_gen.23; - -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.22 (Encode.93): ret Encode.93; @@ -57,12 +41,8 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96): ret Encode.113; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.115 : List U8 = CallByName #Derived.7 Encode.94 Encode.96 Encode.102; - ret Encode.115; - -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.126 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.126; + let Encode.117 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; + ret Encode.117; procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; @@ -75,201 +55,201 @@ procedure Json.1 (): ret Json.102; procedure Json.17 (Json.64): - let Json.146 : {Str} = Struct {Json.64}; - let Json.145 : {Str} = CallByName Encode.22 Json.146; - ret Json.145; + let Json.110 : {Str} = Struct {Json.64}; + let Json.109 : {Str} = CallByName Encode.22 Json.110; + ret Json.109; procedure Json.19 (Json.76): let Json.104 : {List {Str, {Str}}} = Struct {Json.76}; let Json.103 : {List {Str, {Str}}} = CallByName Encode.22 Json.104; ret Json.103; -procedure Json.65 (Json.66, Json.147, #Attr.12): +procedure Json.65 (Json.66, Json.108, #Attr.12): let Json.64 : Str = StructAtIndex 0 #Attr.12; inc Json.64; dec #Attr.12; - let Json.156 : I32 = 34i64; - let Json.155 : U8 = CallByName Num.123 Json.156; - let Json.153 : List U8 = CallByName List.4 Json.66 Json.155; - let Json.154 : List U8 = CallByName Str.12 Json.64; - let Json.150 : List U8 = CallByName List.8 Json.153 Json.154; - let Json.152 : I32 = 34i64; - let Json.151 : U8 = CallByName Num.123 Json.152; - let Json.149 : List U8 = CallByName List.4 Json.150 Json.151; - ret Json.149; + let Json.153 : I32 = 34i64; + let Json.152 : U8 = CallByName Num.123 Json.153; + let Json.150 : List U8 = CallByName List.4 Json.66 Json.152; + let Json.151 : List U8 = CallByName Str.12 Json.64; + let Json.147 : List U8 = CallByName List.8 Json.150 Json.151; + let Json.149 : I32 = 34i64; + let Json.148 : U8 = CallByName Num.123 Json.149; + let Json.146 : List U8 = CallByName List.4 Json.147 Json.148; + ret Json.146; procedure Json.77 (Json.78, Json.105, #Attr.12): let Json.76 : List {Str, {Str}} = StructAtIndex 0 #Attr.12; inc Json.76; dec #Attr.12; - let Json.138 : I32 = 123i64; - let Json.137 : U8 = CallByName Num.123 Json.138; - let Json.80 : List U8 = CallByName List.4 Json.78 Json.137; - let Json.136 : U64 = CallByName List.6 Json.76; - let Json.113 : {List U8, U64} = Struct {Json.80, Json.136}; - let Json.114 : {} = Struct {}; - let Json.112 : {List U8, U64} = CallByName List.18 Json.76 Json.113 Json.114; + let Json.144 : I32 = 123i64; + let Json.143 : U8 = CallByName Num.123 Json.144; + let Json.80 : List U8 = CallByName List.4 Json.78 Json.143; + let Json.142 : U64 = CallByName List.6 Json.76; + let Json.119 : {List U8, U64} = Struct {Json.80, Json.142}; + let Json.120 : {} = Struct {}; + let Json.118 : {List U8, U64} = CallByName List.18 Json.76 Json.119 Json.120; dec Json.76; - let Json.82 : List U8 = StructAtIndex 0 Json.112; + let Json.82 : List U8 = StructAtIndex 0 Json.118; inc Json.82; - dec Json.112; - let Json.111 : I32 = 125i64; - let Json.110 : U8 = CallByName Num.123 Json.111; - let Json.109 : List U8 = CallByName List.4 Json.82 Json.110; - ret Json.109; + dec Json.118; + let Json.117 : I32 = 125i64; + let Json.116 : U8 = CallByName Num.123 Json.117; + let Json.115 : List U8 = CallByName List.4 Json.82 Json.116; + ret Json.115; -procedure Json.79 (Json.107, Json.108): - let Json.85 : Str = StructAtIndex 0 Json.108; +procedure Json.79 (Json.113, Json.114): + let Json.85 : Str = StructAtIndex 0 Json.114; inc Json.85; - let Json.86 : {Str} = StructAtIndex 1 Json.108; + let Json.86 : {Str} = StructAtIndex 1 Json.114; inc Json.86; - dec Json.108; - let Json.83 : List U8 = StructAtIndex 0 Json.107; + dec Json.114; + let Json.83 : List U8 = StructAtIndex 0 Json.113; inc Json.83; - let Json.84 : U64 = StructAtIndex 1 Json.107; - dec Json.107; - let Json.135 : I32 = 34i64; - let Json.134 : U8 = CallByName Num.123 Json.135; - let Json.132 : List U8 = CallByName List.4 Json.83 Json.134; - let Json.133 : List U8 = CallByName Str.12 Json.85; - let Json.129 : List U8 = CallByName List.8 Json.132 Json.133; - let Json.131 : I32 = 34i64; - let Json.130 : U8 = CallByName Num.123 Json.131; - let Json.126 : List U8 = CallByName List.4 Json.129 Json.130; - let Json.128 : I32 = 58i64; - let Json.127 : U8 = CallByName Num.123 Json.128; - let Json.124 : List U8 = CallByName List.4 Json.126 Json.127; - let Json.125 : {} = Struct {}; - let Json.87 : List U8 = CallByName Encode.23 Json.124 Json.86 Json.125; - joinpoint Json.119 Json.88: - let Json.117 : U64 = 1i64; - let Json.116 : U64 = CallByName Num.20 Json.84 Json.117; - let Json.115 : {List U8, U64} = Struct {Json.88, Json.116}; - ret Json.115; + let Json.84 : U64 = StructAtIndex 1 Json.113; + dec Json.113; + let Json.141 : I32 = 34i64; + let Json.140 : U8 = CallByName Num.123 Json.141; + let Json.138 : List U8 = CallByName List.4 Json.83 Json.140; + let Json.139 : List U8 = CallByName Str.12 Json.85; + let Json.135 : List U8 = CallByName List.8 Json.138 Json.139; + let Json.137 : I32 = 34i64; + let Json.136 : U8 = CallByName Num.123 Json.137; + let Json.132 : List U8 = CallByName List.4 Json.135 Json.136; + let Json.134 : I32 = 58i64; + let Json.133 : U8 = CallByName Num.123 Json.134; + let Json.130 : List U8 = CallByName List.4 Json.132 Json.133; + let Json.131 : {} = Struct {}; + let Json.87 : List U8 = CallByName Encode.23 Json.130 Json.86 Json.131; + joinpoint Json.125 Json.88: + let Json.123 : U64 = 1i64; + let Json.122 : U64 = CallByName Num.20 Json.84 Json.123; + let Json.121 : {List U8, U64} = Struct {Json.88, Json.122}; + ret Json.121; in - let Json.123 : U64 = 0i64; - let Json.120 : Int1 = CallByName Num.24 Json.84 Json.123; - if Json.120 then - let Json.122 : I32 = 44i64; - let Json.121 : U8 = CallByName Num.123 Json.122; - let Json.118 : List U8 = CallByName List.4 Json.87 Json.121; - jump Json.119 Json.118; + let Json.129 : U64 = 0i64; + let Json.126 : Int1 = CallByName Num.24 Json.84 Json.129; + if Json.126 then + let Json.128 : I32 = 44i64; + let Json.127 : U8 = CallByName Num.123 Json.128; + let Json.124 : List U8 = CallByName List.4 Json.87 Json.127; + jump Json.125 Json.124; else - jump Json.119 Json.87; + jump Json.125 Json.87; procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; - let List.344 : {List U8, U64} = CallByName Json.79 List.123 List.124; - let List.343 : [C [], C {List U8, U64}] = TagId(1) List.344; - ret List.343; + let List.351 : {List U8, U64} = CallByName Json.79 List.123 List.124; + let List.350 : [C [], C {List U8, U64}] = TagId(1) List.351; + ret List.350; procedure List.18 (List.119, List.120, List.121): - let List.321 : {{}} = Struct {List.121}; - let List.315 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.321; - let List.318 : U8 = 1i64; - let List.319 : U8 = GetTagId List.315; - let List.320 : Int1 = lowlevel Eq List.318 List.319; - if List.320 then - let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.315; + let List.327 : {{}} = Struct {List.121}; + let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327; + let List.324 : U8 = 1i64; + let List.325 : U8 = GetTagId List.321; + let List.326 : Int1 = lowlevel Eq List.324 List.325; + if List.326 then + let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321; inc List.126; - dec List.315; + dec List.321; ret List.126; else - let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.315; - dec List.315; - let List.317 : {List U8, U64} = CallByName List.64 List.127; - ret List.317; + let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321; + dec List.321; + let List.323 : {List U8, U64} = CallByName List.64 List.127; + ret List.323; procedure List.4 (List.90, List.91): - let List.376 : U64 = 1i64; - let List.375 : List U8 = CallByName List.65 List.90 List.376; - let List.374 : List U8 = CallByName List.66 List.375 List.91; - ret List.374; + let List.320 : U64 = 1i64; + let List.319 : List U8 = CallByName List.65 List.90 List.320; + let List.318 : List U8 = CallByName List.66 List.319 List.91; + ret List.318; procedure List.6 (#Attr.2): let List.295 : U64 = lowlevel ListLen #Attr.2; ret List.295; procedure List.6 (#Attr.2): - let List.323 : U64 = lowlevel ListLen #Attr.2; - ret List.323; + let List.330 : U64 = lowlevel ListLen #Attr.2; + ret List.330; procedure List.60 (#Attr.2, #Attr.3): - let List.342 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.342; + let List.349 : {Str, {Str}} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.349; procedure List.63 (List.283, List.284, List.285): - let List.328 : U64 = 0i64; - let List.329 : U64 = CallByName List.6 List.283; - let List.327 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.328 List.329; - ret List.327; + let List.335 : U64 = 0i64; + let List.336 : U64 = CallByName List.6 List.283; + let List.334 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.335 List.336; + ret List.334; procedure List.64 (#Attr.2): - let List.326 : {List U8, U64} = lowlevel Unreachable #Attr.2; - ret List.326; + let List.333 : {List U8, U64} = lowlevel Unreachable #Attr.2; + ret List.333; procedure List.65 (#Attr.2, #Attr.3): - let List.379 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.379; + let List.332 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.332; procedure List.66 (#Attr.2, #Attr.3): - let List.378 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.378; + let List.331 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.331; -procedure List.77 (List.361, List.362, List.363, List.364, List.365): - joinpoint List.330 List.286 List.287 List.288 List.289 List.290: - let List.332 : Int1 = CallByName Num.22 List.289 List.290; - if List.332 then - let List.341 : {Str, {Str}} = CallByName List.60 List.286 List.289; - let List.333 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.341 List.288; - let List.338 : U8 = 1i64; - let List.339 : U8 = GetTagId List.333; - let List.340 : Int1 = lowlevel Eq List.338 List.339; - if List.340 then - let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.333; +procedure List.77 (List.368, List.369, List.370, List.371, List.372): + joinpoint List.337 List.286 List.287 List.288 List.289 List.290: + let List.339 : Int1 = CallByName Num.22 List.289 List.290; + if List.339 then + let List.348 : {Str, {Str}} = CallByName List.60 List.286 List.289; + let List.340 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.348 List.288; + let List.345 : U8 = 1i64; + let List.346 : U8 = GetTagId List.340; + let List.347 : Int1 = lowlevel Eq List.345 List.346; + if List.347 then + let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.340; inc List.291; - dec List.333; - let List.336 : U64 = 1i64; - let List.335 : U64 = CallByName Num.19 List.289 List.336; - jump List.330 List.286 List.291 List.288 List.335 List.290; + dec List.340; + let List.343 : U64 = 1i64; + let List.342 : U64 = CallByName Num.19 List.289 List.343; + jump List.337 List.286 List.291 List.288 List.342 List.290; else - let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.333; - dec List.333; - let List.337 : [C [], C {List U8, U64}] = TagId(0) List.292; - ret List.337; + let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.340; + dec List.340; + let List.344 : [C [], C {List U8, U64}] = TagId(0) List.292; + ret List.344; else - let List.331 : [C [], C {List U8, U64}] = TagId(1) List.287; - ret List.331; + let List.338 : [C [], C {List U8, U64}] = TagId(1) List.287; + ret List.338; in - jump List.330 List.361 List.362 List.363 List.364 List.365; + jump List.337 List.368 List.369 List.370 List.371 List.372; procedure List.8 (#Attr.2, #Attr.3): - let List.377 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.377; + let List.329 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.329; procedure Num.123 (#Attr.2): - let Num.277 : U8 = lowlevel NumIntCast #Attr.2; - ret Num.277; - -procedure Num.19 (#Attr.2, #Attr.3): - let Num.265 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.265; - -procedure Num.20 (#Attr.2, #Attr.3): - let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.263; - -procedure Num.22 (#Attr.2, #Attr.3): - let Num.266 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.266; - -procedure Num.24 (#Attr.2, #Attr.3): - let Num.264 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + let Num.264 : U8 = lowlevel NumIntCast #Attr.2; ret Num.264; +procedure Num.19 (#Attr.2, #Attr.3): + let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.267; + +procedure Num.20 (#Attr.2, #Attr.3): + let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.265; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.268; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.266; + procedure Str.12 (#Attr.2): - let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.211; + let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.210; procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; diff --git a/crates/compiler/test_mono/generated/encode_derived_string.txt b/crates/compiler/test_mono/generated/encode_derived_string.txt index adf0abf137..c3d27bbbf8 100644 --- a/crates/compiler/test_mono/generated/encode_derived_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_string.txt @@ -1,33 +1,13 @@ -procedure #Derived.0 (#Derived.1): - let #Derived_gen.1 : {Str} = Struct {#Derived.1}; - let #Derived_gen.0 : {Str} = CallByName Encode.22 #Derived_gen.1; - ret #Derived_gen.0; - -procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12): - let #Derived.1 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.1; - dec #Attr.12; - let #Derived_gen.4 : {Str} = CallByName Json.17 #Derived.1; - let #Derived_gen.3 : List U8 = CallByName Encode.23 #Derived.3 #Derived_gen.4 #Derived.4; - ret #Derived_gen.3; - -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.22 (Encode.93): ret Encode.93; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.106 : List U8 = CallByName #Derived.2 Encode.94 Encode.96 Encode.102; + let Encode.106 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; ret Encode.106; -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.113 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.113; - procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; - let Encode.105 : {Str} = CallByName #Derived.0 Encode.100; + let Encode.105 : {Str} = CallByName Json.17 Encode.100; let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101; ret Encode.103; diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt index b5b675c539..031b27f0e9 100644 --- a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt @@ -12,27 +12,11 @@ procedure #Derived.3 (#Derived.4, #Derived.5, #Attr.12): ret #Derived_gen.3; in let #Derived_gen.7 : Str = "A"; - let #Derived_gen.9 : {Str} = CallByName #Derived.6 #Derived.1; + let #Derived_gen.9 : {Str} = CallByName Json.17 #Derived.1; let #Derived_gen.8 : List {Str} = Array [#Derived_gen.9]; let #Derived_gen.6 : {Str, List {Str}} = CallByName Json.20 #Derived_gen.7 #Derived_gen.8; jump #Derived_gen.5 #Derived_gen.6; -procedure #Derived.6 (#Derived.7): - let #Derived_gen.15 : {Str} = Struct {#Derived.7}; - let #Derived_gen.14 : {Str} = CallByName Encode.22 #Derived_gen.15; - ret #Derived_gen.14; - -procedure #Derived.8 (#Derived.9, #Derived.10, #Attr.12): - let #Derived.7 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.7; - dec #Attr.12; - let #Derived_gen.18 : {Str} = CallByName Json.17 #Derived.7; - let #Derived_gen.17 : List U8 = CallByName Encode.23 #Derived.9 #Derived_gen.18 #Derived.10; - ret #Derived_gen.17; - -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.22 (Encode.93): ret Encode.93; @@ -51,12 +35,8 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96): ret Encode.113; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.115 : List U8 = CallByName #Derived.8 Encode.94 Encode.96 Encode.102; - ret Encode.115; - -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.125 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.125; + let Encode.116 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; + ret Encode.116; procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; @@ -69,28 +49,28 @@ procedure Json.1 (): ret Json.102; procedure Json.17 (Json.64): - let Json.152 : {Str} = Struct {Json.64}; - let Json.151 : {Str} = CallByName Encode.22 Json.152; - ret Json.151; + let Json.107 : {Str} = Struct {Json.64}; + let Json.106 : {Str} = CallByName Encode.22 Json.107; + ret Json.106; procedure Json.20 (Json.89, Json.90): let Json.104 : {Str, List {Str}} = Struct {Json.89, Json.90}; let Json.103 : {Str, List {Str}} = CallByName Encode.22 Json.104; ret Json.103; -procedure Json.65 (Json.66, Json.153, #Attr.12): +procedure Json.65 (Json.66, Json.108, #Attr.12): let Json.64 : Str = StructAtIndex 0 #Attr.12; inc Json.64; dec #Attr.12; - let Json.162 : I32 = 34i64; - let Json.161 : U8 = CallByName Num.123 Json.162; - let Json.159 : List U8 = CallByName List.4 Json.66 Json.161; - let Json.160 : List U8 = CallByName Str.12 Json.64; - let Json.156 : List U8 = CallByName List.8 Json.159 Json.160; - let Json.158 : I32 = 34i64; - let Json.157 : U8 = CallByName Num.123 Json.158; - let Json.155 : List U8 = CallByName List.4 Json.156 Json.157; - ret Json.155; + let Json.155 : I32 = 34i64; + let Json.154 : U8 = CallByName Num.123 Json.155; + let Json.152 : List U8 = CallByName List.4 Json.66 Json.154; + let Json.153 : List U8 = CallByName Str.12 Json.64; + let Json.149 : List U8 = CallByName List.8 Json.152 Json.153; + let Json.151 : I32 = 34i64; + let Json.150 : U8 = CallByName Num.123 Json.151; + let Json.148 : List U8 = CallByName List.4 Json.149 Json.150; + ret Json.148; procedure Json.91 (Json.92, Json.105, #Attr.12): let Json.90 : List {Str} = StructAtIndex 1 #Attr.12; @@ -98,175 +78,175 @@ procedure Json.91 (Json.92, Json.105, #Attr.12): let Json.89 : Str = StructAtIndex 0 #Attr.12; inc Json.89; dec #Attr.12; - let Json.143 : I32 = 123i64; - let Json.142 : U8 = CallByName Num.123 Json.143; - let Json.139 : List U8 = CallByName List.4 Json.92 Json.142; - let Json.141 : I32 = 34i64; - let Json.140 : U8 = CallByName Num.123 Json.141; - let Json.137 : List U8 = CallByName List.4 Json.139 Json.140; - let Json.138 : List U8 = CallByName Str.12 Json.89; - let Json.134 : List U8 = CallByName List.8 Json.137 Json.138; - let Json.136 : I32 = 34i64; + let Json.146 : I32 = 123i64; + let Json.145 : U8 = CallByName Num.123 Json.146; + let Json.142 : List U8 = CallByName List.4 Json.92 Json.145; + let Json.144 : I32 = 34i64; + let Json.143 : U8 = CallByName Num.123 Json.144; + let Json.140 : List U8 = CallByName List.4 Json.142 Json.143; + let Json.141 : List U8 = CallByName Str.12 Json.89; + let Json.137 : List U8 = CallByName List.8 Json.140 Json.141; + let Json.139 : I32 = 34i64; + let Json.138 : U8 = CallByName Num.123 Json.139; + let Json.134 : List U8 = CallByName List.4 Json.137 Json.138; + let Json.136 : I32 = 58i64; let Json.135 : U8 = CallByName Num.123 Json.136; let Json.131 : List U8 = CallByName List.4 Json.134 Json.135; - let Json.133 : I32 = 58i64; + let Json.133 : I32 = 91i64; let Json.132 : U8 = CallByName Num.123 Json.133; - let Json.128 : List U8 = CallByName List.4 Json.131 Json.132; - let Json.130 : I32 = 91i64; - let Json.129 : U8 = CallByName Num.123 Json.130; - let Json.94 : List U8 = CallByName List.4 Json.128 Json.129; - let Json.127 : U64 = CallByName List.6 Json.90; - let Json.115 : {List U8, U64} = Struct {Json.94, Json.127}; - let Json.116 : {} = Struct {}; - let Json.114 : {List U8, U64} = CallByName List.18 Json.90 Json.115 Json.116; + let Json.94 : List U8 = CallByName List.4 Json.131 Json.132; + let Json.130 : U64 = CallByName List.6 Json.90; + let Json.118 : {List U8, U64} = Struct {Json.94, Json.130}; + let Json.119 : {} = Struct {}; + let Json.117 : {List U8, U64} = CallByName List.18 Json.90 Json.118 Json.119; dec Json.90; - let Json.96 : List U8 = StructAtIndex 0 Json.114; + let Json.96 : List U8 = StructAtIndex 0 Json.117; inc Json.96; - dec Json.114; - let Json.113 : I32 = 93i64; - let Json.112 : U8 = CallByName Num.123 Json.113; - let Json.109 : List U8 = CallByName List.4 Json.96 Json.112; - let Json.111 : I32 = 125i64; - let Json.110 : U8 = CallByName Num.123 Json.111; - let Json.108 : List U8 = CallByName List.4 Json.109 Json.110; - ret Json.108; + dec Json.117; + let Json.116 : I32 = 93i64; + let Json.115 : U8 = CallByName Num.123 Json.116; + let Json.112 : List U8 = CallByName List.4 Json.96 Json.115; + let Json.114 : I32 = 125i64; + let Json.113 : U8 = CallByName Num.123 Json.114; + let Json.111 : List U8 = CallByName List.4 Json.112 Json.113; + ret Json.111; -procedure Json.93 (Json.107, Json.99): - let Json.97 : List U8 = StructAtIndex 0 Json.107; +procedure Json.93 (Json.110, Json.99): + let Json.97 : List U8 = StructAtIndex 0 Json.110; inc Json.97; - let Json.98 : U64 = StructAtIndex 1 Json.107; - dec Json.107; - let Json.126 : {} = Struct {}; - let Json.100 : List U8 = CallByName Encode.23 Json.97 Json.99 Json.126; - joinpoint Json.121 Json.101: - let Json.119 : U64 = 1i64; - let Json.118 : U64 = CallByName Num.20 Json.98 Json.119; - let Json.117 : {List U8, U64} = Struct {Json.101, Json.118}; - ret Json.117; + let Json.98 : U64 = StructAtIndex 1 Json.110; + dec Json.110; + let Json.129 : {} = Struct {}; + let Json.100 : List U8 = CallByName Encode.23 Json.97 Json.99 Json.129; + joinpoint Json.124 Json.101: + let Json.122 : U64 = 1i64; + let Json.121 : U64 = CallByName Num.20 Json.98 Json.122; + let Json.120 : {List U8, U64} = Struct {Json.101, Json.121}; + ret Json.120; in - let Json.125 : U64 = 0i64; - let Json.122 : Int1 = CallByName Num.24 Json.98 Json.125; - if Json.122 then - let Json.124 : I32 = 44i64; - let Json.123 : U8 = CallByName Num.123 Json.124; - let Json.120 : List U8 = CallByName List.4 Json.100 Json.123; - jump Json.121 Json.120; + let Json.128 : U64 = 0i64; + let Json.125 : Int1 = CallByName Num.24 Json.98 Json.128; + if Json.125 then + let Json.127 : I32 = 44i64; + let Json.126 : U8 = CallByName Num.123 Json.127; + let Json.123 : List U8 = CallByName List.4 Json.100 Json.126; + jump Json.124 Json.123; else - jump Json.121 Json.100; + jump Json.124 Json.100; procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; - let List.350 : {List U8, U64} = CallByName Json.93 List.123 List.124; - let List.349 : [C [], C {List U8, U64}] = TagId(1) List.350; - ret List.349; + let List.357 : {List U8, U64} = CallByName Json.93 List.123 List.124; + let List.356 : [C [], C {List U8, U64}] = TagId(1) List.357; + ret List.356; procedure List.18 (List.119, List.120, List.121): - let List.327 : {{}} = Struct {List.121}; - let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327; - let List.324 : U8 = 1i64; - let List.325 : U8 = GetTagId List.321; - let List.326 : Int1 = lowlevel Eq List.324 List.325; - if List.326 then - let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321; + let List.333 : {{}} = Struct {List.121}; + let List.327 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.333; + let List.330 : U8 = 1i64; + let List.331 : U8 = GetTagId List.327; + let List.332 : Int1 = lowlevel Eq List.330 List.331; + if List.332 then + let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.327; inc List.126; - dec List.321; + dec List.327; ret List.126; else - let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321; - dec List.321; - let List.323 : {List U8, U64} = CallByName List.64 List.127; - ret List.323; + let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.327; + dec List.327; + let List.329 : {List U8, U64} = CallByName List.64 List.127; + ret List.329; procedure List.4 (List.90, List.91): - let List.382 : U64 = 1i64; - let List.381 : List U8 = CallByName List.65 List.90 List.382; - let List.380 : List U8 = CallByName List.66 List.381 List.91; - ret List.380; + let List.326 : U64 = 1i64; + let List.325 : List U8 = CallByName List.65 List.90 List.326; + let List.324 : List U8 = CallByName List.66 List.325 List.91; + ret List.324; procedure List.6 (#Attr.2): let List.295 : U64 = lowlevel ListLen #Attr.2; ret List.295; procedure List.6 (#Attr.2): - let List.328 : U64 = lowlevel ListLen #Attr.2; - ret List.328; + let List.334 : U64 = lowlevel ListLen #Attr.2; + ret List.334; procedure List.60 (#Attr.2, #Attr.3): - let List.348 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.348; + let List.355 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.355; procedure List.63 (List.283, List.284, List.285): - let List.334 : U64 = 0i64; - let List.335 : U64 = CallByName List.6 List.283; - let List.333 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.334 List.335; - ret List.333; + let List.341 : U64 = 0i64; + let List.342 : U64 = CallByName List.6 List.283; + let List.340 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.341 List.342; + ret List.340; procedure List.64 (#Attr.2): - let List.332 : {List U8, U64} = lowlevel Unreachable #Attr.2; - ret List.332; + let List.339 : {List U8, U64} = lowlevel Unreachable #Attr.2; + ret List.339; procedure List.65 (#Attr.2, #Attr.3): - let List.385 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.385; + let List.338 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.338; procedure List.66 (#Attr.2, #Attr.3): - let List.384 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.384; + let List.337 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.337; -procedure List.77 (List.367, List.368, List.369, List.370, List.371): - joinpoint List.336 List.286 List.287 List.288 List.289 List.290: - let List.338 : Int1 = CallByName Num.22 List.289 List.290; - if List.338 then - let List.347 : {Str} = CallByName List.60 List.286 List.289; - let List.339 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.347 List.288; - let List.344 : U8 = 1i64; - let List.345 : U8 = GetTagId List.339; - let List.346 : Int1 = lowlevel Eq List.344 List.345; - if List.346 then - let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.339; +procedure List.77 (List.374, List.375, List.376, List.377, List.378): + joinpoint List.343 List.286 List.287 List.288 List.289 List.290: + let List.345 : Int1 = CallByName Num.22 List.289 List.290; + if List.345 then + let List.354 : {Str} = CallByName List.60 List.286 List.289; + let List.346 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.354 List.288; + let List.351 : U8 = 1i64; + let List.352 : U8 = GetTagId List.346; + let List.353 : Int1 = lowlevel Eq List.351 List.352; + if List.353 then + let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.346; inc List.291; - dec List.339; - let List.342 : U64 = 1i64; - let List.341 : U64 = CallByName Num.19 List.289 List.342; - jump List.336 List.286 List.291 List.288 List.341 List.290; + dec List.346; + let List.349 : U64 = 1i64; + let List.348 : U64 = CallByName Num.19 List.289 List.349; + jump List.343 List.286 List.291 List.288 List.348 List.290; else - let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.339; - dec List.339; - let List.343 : [C [], C {List U8, U64}] = TagId(0) List.292; - ret List.343; + let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.346; + dec List.346; + let List.350 : [C [], C {List U8, U64}] = TagId(0) List.292; + ret List.350; else - let List.337 : [C [], C {List U8, U64}] = TagId(1) List.287; - ret List.337; + let List.344 : [C [], C {List U8, U64}] = TagId(1) List.287; + ret List.344; in - jump List.336 List.367 List.368 List.369 List.370 List.371; + jump List.343 List.374 List.375 List.376 List.377 List.378; procedure List.8 (#Attr.2, #Attr.3): - let List.383 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.383; + let List.336 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.336; procedure Num.123 (#Attr.2): - let Num.279 : U8 = lowlevel NumIntCast #Attr.2; - ret Num.279; - -procedure Num.19 (#Attr.2, #Attr.3): - let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.267; - -procedure Num.20 (#Attr.2, #Attr.3): - let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.265; - -procedure Num.22 (#Attr.2, #Attr.3): - let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.268; - -procedure Num.24 (#Attr.2, #Attr.3): - let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + let Num.266 : U8 = lowlevel NumIntCast #Attr.2; ret Num.266; +procedure Num.19 (#Attr.2, #Attr.3): + let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.269; + +procedure Num.20 (#Attr.2, #Attr.3): + let Num.267 : U64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.267; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.270; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.268 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.268; + procedure Str.12 (#Attr.2): - let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.211; + let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.210; procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt index e2a8c7ab1b..10098c3120 100644 --- a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt @@ -17,28 +17,12 @@ procedure #Derived.4 (#Derived.5, #Derived.6, #Attr.12): inc #Derived.3; dec #Derived.1; let #Derived_gen.7 : Str = "A"; - let #Derived_gen.9 : {Str} = CallByName #Derived.7 #Derived.2; - let #Derived_gen.10 : {Str} = CallByName #Derived.7 #Derived.3; + let #Derived_gen.9 : {Str} = CallByName Json.17 #Derived.2; + let #Derived_gen.10 : {Str} = CallByName Json.17 #Derived.3; let #Derived_gen.8 : List {Str} = Array [#Derived_gen.9, #Derived_gen.10]; let #Derived_gen.6 : {Str, List {Str}} = CallByName Json.20 #Derived_gen.7 #Derived_gen.8; jump #Derived_gen.5 #Derived_gen.6; -procedure #Derived.7 (#Derived.8): - let #Derived_gen.18 : {Str} = Struct {#Derived.8}; - let #Derived_gen.17 : {Str} = CallByName Encode.22 #Derived_gen.18; - ret #Derived_gen.17; - -procedure #Derived.9 (#Derived.10, #Derived.11, #Attr.12): - let #Derived.8 : Str = StructAtIndex 0 #Attr.12; - inc #Derived.8; - dec #Attr.12; - let #Derived_gen.21 : {Str} = CallByName Json.17 #Derived.8; - let #Derived_gen.20 : List U8 = CallByName Encode.23 #Derived.10 #Derived_gen.21 #Derived.11; - ret #Derived_gen.20; - -procedure Encode.22 (Encode.93): - ret Encode.93; - procedure Encode.22 (Encode.93): ret Encode.93; @@ -57,12 +41,8 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96): ret Encode.113; procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.115 : List U8 = CallByName #Derived.9 Encode.94 Encode.96 Encode.102; - ret Encode.115; - -procedure Encode.23 (Encode.94, Encode.102, Encode.96): - let Encode.126 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; - ret Encode.126; + let Encode.117 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102; + ret Encode.117; procedure Encode.25 (Encode.100, Encode.101): let Encode.104 : List U8 = Array []; @@ -75,28 +55,28 @@ procedure Json.1 (): ret Json.102; procedure Json.17 (Json.64): - let Json.152 : {Str} = Struct {Json.64}; - let Json.151 : {Str} = CallByName Encode.22 Json.152; - ret Json.151; + let Json.110 : {Str} = Struct {Json.64}; + let Json.109 : {Str} = CallByName Encode.22 Json.110; + ret Json.109; procedure Json.20 (Json.89, Json.90): let Json.104 : {Str, List {Str}} = Struct {Json.89, Json.90}; let Json.103 : {Str, List {Str}} = CallByName Encode.22 Json.104; ret Json.103; -procedure Json.65 (Json.66, Json.153, #Attr.12): +procedure Json.65 (Json.66, Json.108, #Attr.12): let Json.64 : Str = StructAtIndex 0 #Attr.12; inc Json.64; dec #Attr.12; - let Json.162 : I32 = 34i64; - let Json.161 : U8 = CallByName Num.123 Json.162; - let Json.159 : List U8 = CallByName List.4 Json.66 Json.161; - let Json.160 : List U8 = CallByName Str.12 Json.64; - let Json.156 : List U8 = CallByName List.8 Json.159 Json.160; let Json.158 : I32 = 34i64; let Json.157 : U8 = CallByName Num.123 Json.158; - let Json.155 : List U8 = CallByName List.4 Json.156 Json.157; - ret Json.155; + let Json.155 : List U8 = CallByName List.4 Json.66 Json.157; + let Json.156 : List U8 = CallByName Str.12 Json.64; + let Json.152 : List U8 = CallByName List.8 Json.155 Json.156; + let Json.154 : I32 = 34i64; + let Json.153 : U8 = CallByName Num.123 Json.154; + let Json.151 : List U8 = CallByName List.4 Json.152 Json.153; + ret Json.151; procedure Json.91 (Json.92, Json.105, #Attr.12): let Json.90 : List {Str} = StructAtIndex 1 #Attr.12; @@ -104,175 +84,175 @@ procedure Json.91 (Json.92, Json.105, #Attr.12): let Json.89 : Str = StructAtIndex 0 #Attr.12; inc Json.89; dec #Attr.12; - let Json.143 : I32 = 123i64; - let Json.142 : U8 = CallByName Num.123 Json.143; - let Json.139 : List U8 = CallByName List.4 Json.92 Json.142; - let Json.141 : I32 = 34i64; - let Json.140 : U8 = CallByName Num.123 Json.141; - let Json.137 : List U8 = CallByName List.4 Json.139 Json.140; - let Json.138 : List U8 = CallByName Str.12 Json.89; - let Json.134 : List U8 = CallByName List.8 Json.137 Json.138; - let Json.136 : I32 = 34i64; + let Json.149 : I32 = 123i64; + let Json.148 : U8 = CallByName Num.123 Json.149; + let Json.145 : List U8 = CallByName List.4 Json.92 Json.148; + let Json.147 : I32 = 34i64; + let Json.146 : U8 = CallByName Num.123 Json.147; + let Json.143 : List U8 = CallByName List.4 Json.145 Json.146; + let Json.144 : List U8 = CallByName Str.12 Json.89; + let Json.140 : List U8 = CallByName List.8 Json.143 Json.144; + let Json.142 : I32 = 34i64; + let Json.141 : U8 = CallByName Num.123 Json.142; + let Json.137 : List U8 = CallByName List.4 Json.140 Json.141; + let Json.139 : I32 = 58i64; + let Json.138 : U8 = CallByName Num.123 Json.139; + let Json.134 : List U8 = CallByName List.4 Json.137 Json.138; + let Json.136 : I32 = 91i64; let Json.135 : U8 = CallByName Num.123 Json.136; - let Json.131 : List U8 = CallByName List.4 Json.134 Json.135; - let Json.133 : I32 = 58i64; - let Json.132 : U8 = CallByName Num.123 Json.133; - let Json.128 : List U8 = CallByName List.4 Json.131 Json.132; - let Json.130 : I32 = 91i64; - let Json.129 : U8 = CallByName Num.123 Json.130; - let Json.94 : List U8 = CallByName List.4 Json.128 Json.129; - let Json.127 : U64 = CallByName List.6 Json.90; - let Json.115 : {List U8, U64} = Struct {Json.94, Json.127}; - let Json.116 : {} = Struct {}; - let Json.114 : {List U8, U64} = CallByName List.18 Json.90 Json.115 Json.116; + let Json.94 : List U8 = CallByName List.4 Json.134 Json.135; + let Json.133 : U64 = CallByName List.6 Json.90; + let Json.121 : {List U8, U64} = Struct {Json.94, Json.133}; + let Json.122 : {} = Struct {}; + let Json.120 : {List U8, U64} = CallByName List.18 Json.90 Json.121 Json.122; dec Json.90; - let Json.96 : List U8 = StructAtIndex 0 Json.114; + let Json.96 : List U8 = StructAtIndex 0 Json.120; inc Json.96; - dec Json.114; - let Json.113 : I32 = 93i64; - let Json.112 : U8 = CallByName Num.123 Json.113; - let Json.109 : List U8 = CallByName List.4 Json.96 Json.112; - let Json.111 : I32 = 125i64; - let Json.110 : U8 = CallByName Num.123 Json.111; - let Json.108 : List U8 = CallByName List.4 Json.109 Json.110; - ret Json.108; + dec Json.120; + let Json.119 : I32 = 93i64; + let Json.118 : U8 = CallByName Num.123 Json.119; + let Json.115 : List U8 = CallByName List.4 Json.96 Json.118; + let Json.117 : I32 = 125i64; + let Json.116 : U8 = CallByName Num.123 Json.117; + let Json.114 : List U8 = CallByName List.4 Json.115 Json.116; + ret Json.114; -procedure Json.93 (Json.107, Json.99): - let Json.97 : List U8 = StructAtIndex 0 Json.107; +procedure Json.93 (Json.113, Json.99): + let Json.97 : List U8 = StructAtIndex 0 Json.113; inc Json.97; - let Json.98 : U64 = StructAtIndex 1 Json.107; - dec Json.107; - let Json.126 : {} = Struct {}; - let Json.100 : List U8 = CallByName Encode.23 Json.97 Json.99 Json.126; - joinpoint Json.121 Json.101: - let Json.119 : U64 = 1i64; - let Json.118 : U64 = CallByName Num.20 Json.98 Json.119; - let Json.117 : {List U8, U64} = Struct {Json.101, Json.118}; - ret Json.117; + let Json.98 : U64 = StructAtIndex 1 Json.113; + dec Json.113; + let Json.132 : {} = Struct {}; + let Json.100 : List U8 = CallByName Encode.23 Json.97 Json.99 Json.132; + joinpoint Json.127 Json.101: + let Json.125 : U64 = 1i64; + let Json.124 : U64 = CallByName Num.20 Json.98 Json.125; + let Json.123 : {List U8, U64} = Struct {Json.101, Json.124}; + ret Json.123; in - let Json.125 : U64 = 0i64; - let Json.122 : Int1 = CallByName Num.24 Json.98 Json.125; - if Json.122 then - let Json.124 : I32 = 44i64; - let Json.123 : U8 = CallByName Num.123 Json.124; - let Json.120 : List U8 = CallByName List.4 Json.100 Json.123; - jump Json.121 Json.120; + let Json.131 : U64 = 0i64; + let Json.128 : Int1 = CallByName Num.24 Json.98 Json.131; + if Json.128 then + let Json.130 : I32 = 44i64; + let Json.129 : U8 = CallByName Num.123 Json.130; + let Json.126 : List U8 = CallByName List.4 Json.100 Json.129; + jump Json.127 Json.126; else - jump Json.121 Json.100; + jump Json.127 Json.100; procedure List.122 (List.123, List.124, #Attr.12): let List.121 : {} = StructAtIndex 0 #Attr.12; - let List.350 : {List U8, U64} = CallByName Json.93 List.123 List.124; - let List.349 : [C [], C {List U8, U64}] = TagId(1) List.350; - ret List.349; + let List.357 : {List U8, U64} = CallByName Json.93 List.123 List.124; + let List.356 : [C [], C {List U8, U64}] = TagId(1) List.357; + ret List.356; procedure List.18 (List.119, List.120, List.121): - let List.327 : {{}} = Struct {List.121}; - let List.321 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.327; - let List.324 : U8 = 1i64; - let List.325 : U8 = GetTagId List.321; - let List.326 : Int1 = lowlevel Eq List.324 List.325; - if List.326 then - let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.321; + let List.333 : {{}} = Struct {List.121}; + let List.327 : [C [], C {List U8, U64}] = CallByName List.63 List.119 List.120 List.333; + let List.330 : U8 = 1i64; + let List.331 : U8 = GetTagId List.327; + let List.332 : Int1 = lowlevel Eq List.330 List.331; + if List.332 then + let List.126 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.327; inc List.126; - dec List.321; + dec List.327; ret List.126; else - let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.321; - dec List.321; - let List.323 : {List U8, U64} = CallByName List.64 List.127; - ret List.323; + let List.127 : [] = UnionAtIndex (Id 0) (Index 0) List.327; + dec List.327; + let List.329 : {List U8, U64} = CallByName List.64 List.127; + ret List.329; procedure List.4 (List.90, List.91): - let List.382 : U64 = 1i64; - let List.381 : List U8 = CallByName List.65 List.90 List.382; - let List.380 : List U8 = CallByName List.66 List.381 List.91; - ret List.380; + let List.326 : U64 = 1i64; + let List.325 : List U8 = CallByName List.65 List.90 List.326; + let List.324 : List U8 = CallByName List.66 List.325 List.91; + ret List.324; procedure List.6 (#Attr.2): let List.295 : U64 = lowlevel ListLen #Attr.2; ret List.295; procedure List.6 (#Attr.2): - let List.328 : U64 = lowlevel ListLen #Attr.2; - ret List.328; + let List.334 : U64 = lowlevel ListLen #Attr.2; + ret List.334; procedure List.60 (#Attr.2, #Attr.3): - let List.348 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.348; + let List.355 : {Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.355; procedure List.63 (List.283, List.284, List.285): - let List.334 : U64 = 0i64; - let List.335 : U64 = CallByName List.6 List.283; - let List.333 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.334 List.335; - ret List.333; + let List.341 : U64 = 0i64; + let List.342 : U64 = CallByName List.6 List.283; + let List.340 : [C [], C {List U8, U64}] = CallByName List.77 List.283 List.284 List.285 List.341 List.342; + ret List.340; procedure List.64 (#Attr.2): - let List.332 : {List U8, U64} = lowlevel Unreachable #Attr.2; - ret List.332; + let List.339 : {List U8, U64} = lowlevel Unreachable #Attr.2; + ret List.339; procedure List.65 (#Attr.2, #Attr.3): - let List.385 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.385; + let List.338 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.338; procedure List.66 (#Attr.2, #Attr.3): - let List.384 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.384; + let List.337 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.337; -procedure List.77 (List.367, List.368, List.369, List.370, List.371): - joinpoint List.336 List.286 List.287 List.288 List.289 List.290: - let List.338 : Int1 = CallByName Num.22 List.289 List.290; - if List.338 then - let List.347 : {Str} = CallByName List.60 List.286 List.289; - let List.339 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.347 List.288; - let List.344 : U8 = 1i64; - let List.345 : U8 = GetTagId List.339; - let List.346 : Int1 = lowlevel Eq List.344 List.345; - if List.346 then - let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.339; +procedure List.77 (List.374, List.375, List.376, List.377, List.378): + joinpoint List.343 List.286 List.287 List.288 List.289 List.290: + let List.345 : Int1 = CallByName Num.22 List.289 List.290; + if List.345 then + let List.354 : {Str} = CallByName List.60 List.286 List.289; + let List.346 : [C [], C {List U8, U64}] = CallByName List.122 List.287 List.354 List.288; + let List.351 : U8 = 1i64; + let List.352 : U8 = GetTagId List.346; + let List.353 : Int1 = lowlevel Eq List.351 List.352; + if List.353 then + let List.291 : {List U8, U64} = UnionAtIndex (Id 1) (Index 0) List.346; inc List.291; - dec List.339; - let List.342 : U64 = 1i64; - let List.341 : U64 = CallByName Num.19 List.289 List.342; - jump List.336 List.286 List.291 List.288 List.341 List.290; + dec List.346; + let List.349 : U64 = 1i64; + let List.348 : U64 = CallByName Num.19 List.289 List.349; + jump List.343 List.286 List.291 List.288 List.348 List.290; else - let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.339; - dec List.339; - let List.343 : [C [], C {List U8, U64}] = TagId(0) List.292; - ret List.343; + let List.292 : [] = UnionAtIndex (Id 0) (Index 0) List.346; + dec List.346; + let List.350 : [C [], C {List U8, U64}] = TagId(0) List.292; + ret List.350; else - let List.337 : [C [], C {List U8, U64}] = TagId(1) List.287; - ret List.337; + let List.344 : [C [], C {List U8, U64}] = TagId(1) List.287; + ret List.344; in - jump List.336 List.367 List.368 List.369 List.370 List.371; + jump List.343 List.374 List.375 List.376 List.377 List.378; procedure List.8 (#Attr.2, #Attr.3): - let List.383 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.383; + let List.336 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.336; procedure Num.123 (#Attr.2): - let Num.279 : U8 = lowlevel NumIntCast #Attr.2; - ret Num.279; - -procedure Num.19 (#Attr.2, #Attr.3): - let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.267; - -procedure Num.20 (#Attr.2, #Attr.3): - let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.265; - -procedure Num.22 (#Attr.2, #Attr.3): - let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.268; - -procedure Num.24 (#Attr.2, #Attr.3): - let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + let Num.266 : U8 = lowlevel NumIntCast #Attr.2; ret Num.266; +procedure Num.19 (#Attr.2, #Attr.3): + let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.269; + +procedure Num.20 (#Attr.2, #Attr.3): + let Num.267 : U64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.267; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.270; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.268 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.268; + procedure Str.12 (#Attr.2): - let Str.211 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.211; + let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.210; procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; diff --git a/crates/compiler/types/src/subs.rs b/crates/compiler/types/src/subs.rs index e2b96c56d7..fc2715758f 100644 --- a/crates/compiler/types/src/subs.rs +++ b/crates/compiler/types/src/subs.rs @@ -706,6 +706,12 @@ impl GetSubsSlice for Subs { } } +impl GetSubsSlice for Subs { + fn get_subs_slice(&self, subs_slice: SubsSlice) -> &[VariableSubsSlice] { + subs_slice.get_slice(&self.variable_slices) + } +} + impl GetSubsSlice> for Subs { fn get_subs_slice(&self, subs_slice: SubsSlice>) -> &[RecordField<()>] { subs_slice.get_slice(&self.record_fields) @@ -3953,12 +3959,15 @@ fn get_fresh_var_name(state: &mut ErrorTypeState) -> Lowercase { /// - all implicitly exposed variables, which include /// - ability member specializations /// - specialization lambda sets under specialization ability members +/// - lambda sets under ability members defined in the module #[derive(Clone, Debug)] pub struct ExposedTypesStorageSubs { pub storage_subs: StorageSubs, pub stored_vars_by_symbol: VecMap, - /// lambda set var in other module -> var in storage subs + /// specialization lambda set var in other module -> var in storage subs pub stored_specialization_lambda_set_vars: VecMap, + /// ability member signature in other module -> var in storage subs + pub stored_ability_member_vars: VecMap, } #[derive(Clone, Debug)] @@ -5282,3 +5291,81 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) { }); } } + +/// Finds the lambda set of the ability member type (not specialization) at the region `r`, +/// or all lambda sets if no region is specified. +/// +/// Panics if the given function type does not correspond with what's expected of an ability +/// member, namely its lambda sets have more than a single unspecialized lambda set. +pub fn get_member_lambda_sets_at_region(subs: &Subs, var: Variable, target_region: u8) -> Variable { + let mut stack = vec![var]; + + while let Some(var) = stack.pop() { + match subs.get_content_without_compacting(var) { + Content::LambdaSet(LambdaSet { + solved, + recursion_var, + unspecialized, + ambient_function: _, + }) => { + debug_assert!(solved.is_empty()); + debug_assert!(recursion_var.is_none()); + debug_assert_eq!(unspecialized.len(), 1); + let Uls(_, _, region) = subs.get_subs_slice(*unspecialized)[0]; + if region == target_region { + return var; + } + } + Content::Structure(flat_type) => match flat_type { + FlatType::Apply(_, vars) => { + stack.extend(subs.get_subs_slice(*vars)); + } + FlatType::Func(args, lset, ret) => { + stack.extend(subs.get_subs_slice(*args)); + stack.push(*lset); + stack.push(*ret); + } + FlatType::Record(fields, ext) => { + stack.extend(subs.get_subs_slice(fields.variables())); + stack.push(*ext); + } + FlatType::TagUnion(tags, ext) => { + stack.extend( + subs.get_subs_slice(tags.variables()) + .iter() + .flat_map(|slice| subs.get_subs_slice(*slice)), + ); + stack.push(*ext); + } + FlatType::FunctionOrTagUnion(_, _, ext) => { + stack.push(*ext); + } + FlatType::RecursiveTagUnion(rec, tags, ext) => { + stack.push(*rec); + stack.extend( + subs.get_subs_slice(tags.variables()) + .iter() + .flat_map(|slice| subs.get_subs_slice(*slice)), + ); + stack.push(*ext); + } + FlatType::Erroneous(_) | FlatType::EmptyRecord | FlatType::EmptyTagUnion => {} + }, + Content::Alias(_, _, real_var, _) => { + stack.push(*real_var); + } + Content::RangedNumber(_) + | Content::Error + | Content::FlexVar(_) + | Content::RigidVar(_) + | Content::FlexAbleVar(_, _) + | Content::RigidAbleVar(_, _) + | Content::RecursionVar { + structure: _, + opt_name: _, + } => {} + } + } + + internal_error!("No lambda set at region {} found", target_region); +} diff --git a/crates/compiler/types/src/types.rs b/crates/compiler/types/src/types.rs index adfd08b72a..c610caf418 100644 --- a/crates/compiler/types/src/types.rs +++ b/crates/compiler/types/src/types.rs @@ -2769,8 +2769,16 @@ fn instantiate_lambda_sets_as_unspecialized( able_var: Variable, ability_member: Symbol, ) { - // We want to pop and assign lambda sets pre-order for readability, so types - // should be pushed onto the stack in post-order + // REGION-ORDERING: done in pre-order via the following pseudo code: + // + // Type_function = \region -> + // let left_type, new_region = Type (region + 1) + // let right_type, new_region = Type (new_region) + // let func_type = left_type -[Lambda region]-> right_type + // (func_type, new_region) + // + // Since we want to pop types in pre-order, they should be pushed onto the + // stack in post-order let mut stack = vec![typ]; let mut region = 0; diff --git a/crates/compiler/unify/src/unify.rs b/crates/compiler/unify/src/unify.rs index dbfd8e91be..ecdb540f8d 100644 --- a/crates/compiler/unify/src/unify.rs +++ b/crates/compiler/unify/src/unify.rs @@ -5,7 +5,7 @@ use roc_debug_flags::dbg_do; use roc_debug_flags::{ROC_PRINT_MISMATCHES, ROC_PRINT_UNIFICATIONS}; use roc_error_macros::internal_error; use roc_module::ident::{Lowercase, TagName}; -use roc_module::symbol::Symbol; +use roc_module::symbol::{ModuleId, Symbol}; use roc_types::num::{FloatWidth, IntLitWidth, NumericRange}; use roc_types::subs::Content::{self, *}; use roc_types::subs::{ @@ -754,6 +754,15 @@ fn unify_alias( } } +#[inline(always)] +fn opaque_obligation(opaque: Symbol, opaque_var: Variable) -> Obligated { + match opaque.module_id() { + // Numbers should be treated as ad-hoc obligations for ability checking. + ModuleId::NUM => Obligated::Adhoc(opaque_var), + _ => Obligated::Opaque(opaque), + } +} + #[inline(always)] fn unify_opaque( subs: &mut Subs, @@ -772,7 +781,7 @@ fn unify_opaque( // Alias wins merge(subs, ctx, Alias(symbol, args, real_var, kind)) } - FlexAbleVar(_, ability) if args.is_empty() => { + FlexAbleVar(_, ability) => { // Opaque type wins merge_flex_able_with_concrete( subs, @@ -780,7 +789,7 @@ fn unify_opaque( ctx.second, *ability, Alias(symbol, args, real_var, kind), - Obligated::Opaque(symbol), + opaque_obligation(symbol, ctx.first), ) } Alias(_, _, other_real_var, AliasKind::Structural) => { @@ -2562,20 +2571,16 @@ fn unify_flex_able( RecursionVar { .. } => mismatch!("FlexAble with RecursionVar"), LambdaSet(..) => mismatch!("FlexAble with LambdaSet"), - Alias(name, args, _real_var, AliasKind::Opaque) => { - if args.is_empty() { - // Opaque type wins - merge_flex_able_with_concrete( - subs, - ctx, - ctx.first, - ability, - *other, - Obligated::Opaque(*name), - ) - } else { - mismatch!("FlexAble vs Opaque with type vars") - } + Alias(name, _args, _real_var, AliasKind::Opaque) => { + // Opaque type wins + merge_flex_able_with_concrete( + subs, + ctx, + ctx.first, + ability, + *other, + opaque_obligation(*name, ctx.second), + ) } Structure(_) | Alias(_, _, _, AliasKind::Structural) | RangedNumber(..) => {