From 223efe4a2d1fefb319022cea309921b2b4912dec Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 11:22:51 -0800 Subject: [PATCH 01/18] fix using `.. as name` in list patterns --- crates/compiler/mono/src/ir/decision_tree.rs | 4 + crates/compiler/mono/src/ir/pattern.rs | 86 +++++++++++++++++++- crates/compiler/mono/src/layout/semantic.rs | 2 +- 3 files changed, 88 insertions(+), 4 deletions(-) diff --git a/crates/compiler/mono/src/ir/decision_tree.rs b/crates/compiler/mono/src/ir/decision_tree.rs index 90def905cf..745d2cae12 100644 --- a/crates/compiler/mono/src/ir/decision_tree.rs +++ b/crates/compiler/mono/src/ir/decision_tree.rs @@ -634,8 +634,10 @@ fn test_for_pattern<'a>(pattern: &Pattern<'a>) -> Option> { List { arity, + list_layout: _, element_layout: _, elements: _, + opt_rest: _, } => IsListLen { bound: match arity { ListArity::Exact(_) => ListLenBound::Exact, @@ -908,7 +910,9 @@ fn to_relevant_branch_help<'a>( List { arity: my_arity, elements, + list_layout: _, element_layout: _, + opt_rest: _, } => match test { IsListLen { bound: test_bound, diff --git a/crates/compiler/mono/src/ir/pattern.rs b/crates/compiler/mono/src/ir/pattern.rs index 00b422b6a6..f81df80cf7 100644 --- a/crates/compiler/mono/src/ir/pattern.rs +++ b/crates/compiler/mono/src/ir/pattern.rs @@ -1,7 +1,7 @@ use crate::ir::{substitute_in_exprs, Env, Expr, Procs, Stmt}; use crate::layout::{ - self, Builtin, InLayout, Layout, LayoutCache, LayoutInterner, LayoutProblem, LayoutRepr, - TagIdIntType, UnionLayout, WrappedVariant, + self, Builtin, InLayout, LambdaName, Layout, LayoutCache, LayoutInterner, LayoutProblem, + LayoutRepr, LayoutWrapper, SemanticRepr, TagIdIntType, UnionLayout, WrappedVariant, }; use bumpalo::collections::Vec; use roc_builtins::bitcode::{FloatWidth, IntWidth}; @@ -61,8 +61,10 @@ pub enum Pattern<'a> { }, List { arity: ListArity, + list_layout: InLayout<'a>, element_layout: InLayout<'a>, elements: Vec<'a, Pattern<'a>>, + opt_rest: Option<(usize, Option)>, }, } @@ -1050,10 +1052,18 @@ fn from_can_pattern_help<'a>( } List { - list_var: _, + list_var, elem_var, patterns, } => { + let list_layout = match layout_cache.from_var(env.arena, *list_var, env.subs) { + Ok(lay) => lay, + Err(LayoutProblem::UnresolvedTypeVar(_)) => { + return Err(RuntimeError::UnresolvedTypeVar) + } + Err(LayoutProblem::Erroneous) => return Err(RuntimeError::ErroneousType), + }; + let element_layout = match layout_cache.from_var(env.arena, *elem_var, env.subs) { Ok(lay) => lay, Err(LayoutProblem::UnresolvedTypeVar(_)) => { @@ -1073,8 +1083,10 @@ fn from_can_pattern_help<'a>( Ok(Pattern::List { arity, + list_layout, element_layout, elements: mono_patterns, + opt_rest: patterns.opt_rest, }) } } @@ -1240,8 +1252,10 @@ fn store_pattern_help<'a>( List { arity, + list_layout, element_layout, elements, + opt_rest, } => { return store_list_pattern( env, @@ -1249,8 +1263,10 @@ fn store_pattern_help<'a>( layout_cache, outer_symbol, *arity, + *list_layout, *element_layout, elements, + opt_rest, stmt, ) } @@ -1447,8 +1463,10 @@ fn store_list_pattern<'a>( layout_cache: &mut LayoutCache<'a>, list_sym: Symbol, list_arity: ListArity, + list_layout: InLayout<'a>, element_layout: InLayout<'a>, elements: &[Pattern<'a>], + opt_rest: &Option<(usize, Option)>, mut stmt: Stmt<'a>, ) -> StorePattern<'a> { use Pattern::*; @@ -1526,6 +1544,68 @@ fn store_list_pattern<'a>( } } + match opt_rest { + Some((index, Some(rest_sym))) => { + let usize_layout = Layout::usize(env.target_info); + + let total_dropped = elements.len(); + + let total_dropped_sym = env.unique_symbol(); + let total_dropped_expr = + Expr::Literal(Literal::Int((total_dropped as u128).to_ne_bytes())); + + let list_len_sym = env.unique_symbol(); + let list_len_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::ListLen, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_sym]), + }); + + let rest_len_sym = env.unique_symbol(); + let rest_len_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::NumSub, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_len_sym, total_dropped_sym]), + }); + + let start_sym = env.unique_symbol(); + let start_expr = Expr::Literal(Literal::Int((*index as u128).to_ne_bytes())); + + let rest_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::ListSublist, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_sym, start_sym, rest_len_sym]), + }); + stmt = Stmt::Let(*rest_sym, rest_expr, list_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(start_sym, start_expr, usize_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let( + rest_len_sym, + rest_len_expr, + usize_layout, + env.arena.alloc(stmt), + ); + stmt = Stmt::Let( + list_len_sym, + list_len_expr, + usize_layout, + env.arena.alloc(stmt), + ); + stmt = Stmt::Let( + total_dropped_sym, + total_dropped_expr, + usize_layout, + env.arena.alloc(stmt), + ); + } + _ => {} + } + if is_productive { StorePattern::Productive(stmt) } else { diff --git a/crates/compiler/mono/src/layout/semantic.rs b/crates/compiler/mono/src/layout/semantic.rs index 293e719e59..38033657a3 100644 --- a/crates/compiler/mono/src/layout/semantic.rs +++ b/crates/compiler/mono/src/layout/semantic.rs @@ -47,7 +47,7 @@ impl<'a> SemanticRepr<'a> { pub(super) const NONE: Self = Self(Inner::None); pub(super) const EMPTY_RECORD: Self = Self::record(&[]); - pub(super) const fn record(fields: &'a [&'a str]) -> Self { + pub(crate) const fn record(fields: &'a [&'a str]) -> Self { Self(Inner::Record(SemaRecord { fields })) } From 26afbbe8f6fbe3d87bb10bbdafdca8f46e6c76c5 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 11:23:13 -0800 Subject: [PATCH 02/18] remove redunant list.sublist check --- crates/compiler/builtins/roc/List.roc | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/crates/compiler/builtins/roc/List.roc b/crates/compiler/builtins/roc/List.roc index 8094931413..bcfa47366e 100644 --- a/crates/compiler/builtins/roc/List.roc +++ b/crates/compiler/builtins/roc/List.roc @@ -1123,10 +1123,7 @@ findLastIndex = \list, matches -> ## Some languages have a function called **`slice`** which works similarly to this. sublist : List elem, { start : Nat, len : Nat } -> List elem sublist = \list, config -> - if config.len == 0 then - [] - else - sublistLowlevel list config.start config.len + sublistLowlevel list config.start config.len ## low-level slicing operation that does no bounds checking sublistLowlevel : List elem, Nat, Nat -> List elem From 2fb093d4c869e3768f4b199c52aa32e319d32cba Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 11:26:20 -0800 Subject: [PATCH 03/18] clippy --- crates/compiler/mono/src/ir/pattern.rs | 108 ++++++++++++------------- 1 file changed, 52 insertions(+), 56 deletions(-) diff --git a/crates/compiler/mono/src/ir/pattern.rs b/crates/compiler/mono/src/ir/pattern.rs index f81df80cf7..3ce056894c 100644 --- a/crates/compiler/mono/src/ir/pattern.rs +++ b/crates/compiler/mono/src/ir/pattern.rs @@ -1,7 +1,7 @@ use crate::ir::{substitute_in_exprs, Env, Expr, Procs, Stmt}; use crate::layout::{ - self, Builtin, InLayout, LambdaName, Layout, LayoutCache, LayoutInterner, LayoutProblem, - LayoutRepr, LayoutWrapper, SemanticRepr, TagIdIntType, UnionLayout, WrappedVariant, + self, Builtin, InLayout, Layout, LayoutCache, LayoutInterner, LayoutProblem, LayoutRepr, + TagIdIntType, UnionLayout, WrappedVariant, }; use bumpalo::collections::Vec; use roc_builtins::bitcode::{FloatWidth, IntWidth}; @@ -1544,66 +1544,62 @@ fn store_list_pattern<'a>( } } - match opt_rest { - Some((index, Some(rest_sym))) => { - let usize_layout = Layout::usize(env.target_info); + if let Some((index, Some(rest_sym))) = opt_rest { + let usize_layout = Layout::usize(env.target_info); - let total_dropped = elements.len(); + let total_dropped = elements.len(); - let total_dropped_sym = env.unique_symbol(); - let total_dropped_expr = - Expr::Literal(Literal::Int((total_dropped as u128).to_ne_bytes())); + let total_dropped_sym = env.unique_symbol(); + let total_dropped_expr = Expr::Literal(Literal::Int((total_dropped as u128).to_ne_bytes())); - let list_len_sym = env.unique_symbol(); - let list_len_expr = Expr::Call(Call { - call_type: CallType::LowLevel { - op: LowLevel::ListLen, - update_mode: env.next_update_mode_id(), - }, - arguments: env.arena.alloc([list_sym]), - }); + let list_len_sym = env.unique_symbol(); + let list_len_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::ListLen, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_sym]), + }); - let rest_len_sym = env.unique_symbol(); - let rest_len_expr = Expr::Call(Call { - call_type: CallType::LowLevel { - op: LowLevel::NumSub, - update_mode: env.next_update_mode_id(), - }, - arguments: env.arena.alloc([list_len_sym, total_dropped_sym]), - }); + let rest_len_sym = env.unique_symbol(); + let rest_len_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::NumSub, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_len_sym, total_dropped_sym]), + }); - let start_sym = env.unique_symbol(); - let start_expr = Expr::Literal(Literal::Int((*index as u128).to_ne_bytes())); + let start_sym = env.unique_symbol(); + let start_expr = Expr::Literal(Literal::Int((*index as u128).to_ne_bytes())); - let rest_expr = Expr::Call(Call { - call_type: CallType::LowLevel { - op: LowLevel::ListSublist, - update_mode: env.next_update_mode_id(), - }, - arguments: env.arena.alloc([list_sym, start_sym, rest_len_sym]), - }); - stmt = Stmt::Let(*rest_sym, rest_expr, list_layout, env.arena.alloc(stmt)); - stmt = Stmt::Let(start_sym, start_expr, usize_layout, env.arena.alloc(stmt)); - stmt = Stmt::Let( - rest_len_sym, - rest_len_expr, - usize_layout, - env.arena.alloc(stmt), - ); - stmt = Stmt::Let( - list_len_sym, - list_len_expr, - usize_layout, - env.arena.alloc(stmt), - ); - stmt = Stmt::Let( - total_dropped_sym, - total_dropped_expr, - usize_layout, - env.arena.alloc(stmt), - ); - } - _ => {} + let rest_expr = Expr::Call(Call { + call_type: CallType::LowLevel { + op: LowLevel::ListSublist, + update_mode: env.next_update_mode_id(), + }, + arguments: env.arena.alloc([list_sym, start_sym, rest_len_sym]), + }); + stmt = Stmt::Let(*rest_sym, rest_expr, list_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(start_sym, start_expr, usize_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let( + rest_len_sym, + rest_len_expr, + usize_layout, + env.arena.alloc(stmt), + ); + stmt = Stmt::Let( + list_len_sym, + list_len_expr, + usize_layout, + env.arena.alloc(stmt), + ); + stmt = Stmt::Let( + total_dropped_sym, + total_dropped_expr, + usize_layout, + env.arena.alloc(stmt), + ); } if is_productive { From 3e39a32f0ea1409eeff706186410969d2da5b9a3 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 11:30:47 -0800 Subject: [PATCH 04/18] cleanup reversed stores to make logic clearer --- crates/compiler/mono/src/ir/pattern.rs | 30 +++++++++----------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/crates/compiler/mono/src/ir/pattern.rs b/crates/compiler/mono/src/ir/pattern.rs index 3ce056894c..838aa46adb 100644 --- a/crates/compiler/mono/src/ir/pattern.rs +++ b/crates/compiler/mono/src/ir/pattern.rs @@ -1580,26 +1580,16 @@ fn store_list_pattern<'a>( }, arguments: env.arena.alloc([list_sym, start_sym, rest_len_sym]), }); - stmt = Stmt::Let(*rest_sym, rest_expr, list_layout, env.arena.alloc(stmt)); - stmt = Stmt::Let(start_sym, start_expr, usize_layout, env.arena.alloc(stmt)); - stmt = Stmt::Let( - rest_len_sym, - rest_len_expr, - usize_layout, - env.arena.alloc(stmt), - ); - stmt = Stmt::Let( - list_len_sym, - list_len_expr, - usize_layout, - env.arena.alloc(stmt), - ); - stmt = Stmt::Let( - total_dropped_sym, - total_dropped_expr, - usize_layout, - env.arena.alloc(stmt), - ); + let needed_stores = [ + (total_dropped_sym, total_dropped_expr, usize_layout), + (list_len_sym, list_len_expr, usize_layout), + (rest_len_sym, rest_len_expr, usize_layout), + (start_sym, start_expr, usize_layout), + (*rest_sym, rest_expr, list_layout), + ]; + for (sym, expr, lay) in needed_stores.into_iter().rev() { + stmt = Stmt::Let(sym, expr, lay, env.arena.alloc(stmt)); + } } if is_productive { From ee10af2c6874678b4984208a08b3ce323198ef0e Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 12:25:16 -0800 Subject: [PATCH 05/18] add currently broken test case for list `.. as rest` --- crates/compiler/test_gen/src/gen_list.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/crates/compiler/test_gen/src/gen_list.rs b/crates/compiler/test_gen/src/gen_list.rs index d6908cba87..db6863b8da 100644 --- a/crates/compiler/test_gen/src/gen_list.rs +++ b/crates/compiler/test_gen/src/gen_list.rs @@ -4039,4 +4039,27 @@ mod pattern_match { RocList ) } + + #[test] + fn rest_as() { + assert_evals_to!( + r#" + helper : List U8 -> U8 + helper = \l -> when l is + [1, .. as rest, 1] -> helper rest + [1, .. as rest] -> helper rest + [.. as rest, 1] -> helper rest + [first, .., last] | [first as last] -> first + last + [] -> 0 + [ + helper [1, 1, 1], + helper [2, 1], + helper [1, 1, 2, 4, 1], + helper [1, 1, 8, 7, 3, 1, 1, 1], + ] + "#, + RocList::from_slice(&[0, 4, 6, 11]), + RocList + ) + } } From 37a8bbd87c7451538fbf35e4f99078efcd515141 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 14:35:59 -0800 Subject: [PATCH 06/18] correct list pattern match checking to add extra anythings for patterns with rest --- crates/compiler/exhaustive/src/lib.rs | 34 ++++++++++++++++++++++----- 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/crates/compiler/exhaustive/src/lib.rs b/crates/compiler/exhaustive/src/lib.rs index 090b222ace..a28470dc79 100644 --- a/crates/compiler/exhaustive/src/lib.rs +++ b/crates/compiler/exhaustive/src/lib.rs @@ -389,7 +389,6 @@ pub fn is_useful(mut old_matrix: PatternMatrix, mut vector: Row) -> bool { vector.extend(args); } else { // TODO turn this into an iteration over the outer loop rather than bouncing - vector.extend(args); for list_ctor in spec_list_ctors { let mut old_matrix = old_matrix.clone(); let mut spec_matrix = Vec::with_capacity(old_matrix.len()); @@ -400,7 +399,31 @@ pub fn is_useful(mut old_matrix: PatternMatrix, mut vector: Row) -> bool { &mut spec_matrix, ); - if is_useful(spec_matrix, vector.clone()) { + // Add Anythings for the missing elements. + let full_args = if let ListArity::Slice(before, _) = arity { + if arity.min_len() < list_ctor.min_len() { + let (before, after) = args.split_at(before); + let num_extra_wildcards = + list_ctor.min_len() - arity.min_len(); + let extra_wildcards = + std::iter::repeat(&Anything).take(num_extra_wildcards); + + before + .iter() + .chain(extra_wildcards) + .chain(after) + .cloned() + .collect() + } else { + args.clone() + } + } else { + args.clone() + }; + let mut nested_vector = vector.clone(); + nested_vector.extend(full_args); + + if is_useful(spec_matrix, nested_vector) { return true; } } @@ -527,9 +550,8 @@ fn specialize_row_by_list(spec_arity: ListArity, mut row: Row) -> Option { debug_assert!(spec_arity.min_len() > this_arity.min_len()); match this_arity { ListArity::Exact(_) => internal_error!("exact-sized lists cannot cover lists of other minimum length"), - ListArity::Slice(before, after) => { - let before = &args[..before]; - let after = &args[this_arity.min_len() - after..]; + ListArity::Slice(before, _) => { + let (before, after) = args.split_at(before); let num_extra_wildcards = spec_arity.min_len() - this_arity.min_len(); let extra_wildcards = std::iter::repeat(&Anything).take(num_extra_wildcards); @@ -847,7 +869,7 @@ fn build_list_ctors_covering_patterns( } (max_prefix_len, max_suffix_len) }; - let l = inf_cover_prefix + inf_cover_suffix; + let l = inf_cover_prefix + inf_cover_suffix + 1; let exact_size_lists = (min_len..l) // exclusive .map(ListArity::Exact); From f72b8c2c30d2ac288514d4e075215527f36ee081 Mon Sep 17 00:00:00 2001 From: Ayaz Hafiz Date: Mon, 20 Nov 2023 20:56:02 -0600 Subject: [PATCH 07/18] Specialize polymorphic lists against non-polymorphic ones --- crates/compiler/exhaustive/src/lib.rs | 70 ++++++++++++++++----------- 1 file changed, 43 insertions(+), 27 deletions(-) diff --git a/crates/compiler/exhaustive/src/lib.rs b/crates/compiler/exhaustive/src/lib.rs index a28470dc79..5239cb7258 100644 --- a/crates/compiler/exhaustive/src/lib.rs +++ b/crates/compiler/exhaustive/src/lib.rs @@ -399,34 +399,19 @@ pub fn is_useful(mut old_matrix: PatternMatrix, mut vector: Row) -> bool { &mut spec_matrix, ); - // Add Anythings for the missing elements. - let full_args = if let ListArity::Slice(before, _) = arity { - if arity.min_len() < list_ctor.min_len() { - let (before, after) = args.split_at(before); - let num_extra_wildcards = - list_ctor.min_len() - arity.min_len(); - let extra_wildcards = - std::iter::repeat(&Anything).take(num_extra_wildcards); + let mut vector = vector.clone(); + specialize_row_with_polymorphic_list( + &mut vector, + &args, + arity, + list_ctor, + ); - before - .iter() - .chain(extra_wildcards) - .chain(after) - .cloned() - .collect() - } else { - args.clone() - } - } else { - args.clone() - }; - let mut nested_vector = vector.clone(); - nested_vector.extend(full_args); - - if is_useful(spec_matrix, nested_vector) { + if is_useful(spec_matrix, vector) { return true; } } + return false; } } @@ -527,6 +512,36 @@ fn specialize_matrix_by_list( } } +fn specialize_row_with_polymorphic_list( + row: &mut Vec, + list_element_patterns: &[Pattern], + polymorphic_list_ctor: ListArity, + specialized_list_ctor: ListArity, +) { + let min_len = specialized_list_ctor.min_len(); + if list_element_patterns.len() > min_len { + row.extend(list_element_patterns.iter().cloned()); + } + + let (patterns_before, patterns_after) = match polymorphic_list_ctor { + ListArity::Slice(before, after) => ( + &list_element_patterns[..before], + &list_element_patterns[after..], + ), + ListArity::Exact(_) => (list_element_patterns, &[] as &[Pattern]), + }; + + let middle_any_patterns_needed = + specialized_list_ctor.min_len() - polymorphic_list_ctor.min_len(); + let middle_patterns = std::iter::repeat(Anything).take(middle_any_patterns_needed); + + row.extend( + (patterns_before.iter().cloned()) + .chain(middle_patterns) + .chain(patterns_after.iter().cloned()), + ); +} + // Specialize a row that matches a list's constructor(s). // // See the docs on [build_list_ctors_covering_patterns] for more information on how list @@ -550,8 +565,9 @@ fn specialize_row_by_list(spec_arity: ListArity, mut row: Row) -> Option { debug_assert!(spec_arity.min_len() > this_arity.min_len()); match this_arity { ListArity::Exact(_) => internal_error!("exact-sized lists cannot cover lists of other minimum length"), - ListArity::Slice(before, _) => { - let (before, after) = args.split_at(before); + ListArity::Slice(before, after) => { + let before = &args[..before]; + let after = &args[this_arity.min_len() - after..]; let num_extra_wildcards = spec_arity.min_len() - this_arity.min_len(); let extra_wildcards = std::iter::repeat(&Anything).take(num_extra_wildcards); @@ -869,7 +885,7 @@ fn build_list_ctors_covering_patterns( } (max_prefix_len, max_suffix_len) }; - let l = inf_cover_prefix + inf_cover_suffix + 1; + let l = inf_cover_prefix + inf_cover_suffix; let exact_size_lists = (min_len..l) // exclusive .map(ListArity::Exact); From bf7be1533be83c498daaff3458eb8f60d95676f1 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 19:49:08 -0800 Subject: [PATCH 08/18] fix indexing --- crates/compiler/exhaustive/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/compiler/exhaustive/src/lib.rs b/crates/compiler/exhaustive/src/lib.rs index 5239cb7258..c4b36af214 100644 --- a/crates/compiler/exhaustive/src/lib.rs +++ b/crates/compiler/exhaustive/src/lib.rs @@ -526,7 +526,7 @@ fn specialize_row_with_polymorphic_list( let (patterns_before, patterns_after) = match polymorphic_list_ctor { ListArity::Slice(before, after) => ( &list_element_patterns[..before], - &list_element_patterns[after..], + &list_element_patterns[list_element_patterns.len() - after..], ), ListArity::Exact(_) => (list_element_patterns, &[] as &[Pattern]), }; From 9cf0d5366f0b9189618ad8bb571a3c72a61de8a5 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 19:59:52 -0800 Subject: [PATCH 09/18] add test case for exhaustiveness checking of list with rest and front and back --- crates/compiler/load/tests/test_reporting.rs | 41 ++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/crates/compiler/load/tests/test_reporting.rs b/crates/compiler/load/tests/test_reporting.rs index cf516a53e8..55352fbd36 100644 --- a/crates/compiler/load/tests/test_reporting.rs +++ b/crates/compiler/load/tests/test_reporting.rs @@ -12596,6 +12596,47 @@ In roc, functions are always written as a lambda, like{} "### ); + test_no_problem!( + list_match_spread_required_front_back, + indoc!( + r#" + l : List [A, B] + + when l is + [A, ..] -> "" + [.., A] -> "" + [..] -> "" + "# + ) + ); + + test_report!( + list_match_spread_redundant_front_back, + indoc!( + r#" + l : List [A] + + when l is + [A, ..] -> "" + [.., A] -> "" + [..] -> "" + "# + ), + @r###" + ── REDUNDANT PATTERN ───────────────────────────────────── /code/proj/Main.roc ─ + + The 2nd pattern is redundant: + + 6│ when l is + 7│ [A, ..] -> "" + 8│> [.., A] -> "" + 9│ [..] -> "" + + Any value of this shape will be handled by a previous pattern, so this + one should be removed. + "### + ); + test_no_problem!( list_match_exhaustive_empty_and_rest_with_unary_head, indoc!( From 2de96ed5a8d0a87568cc670dad6e16cf19d83c61 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 20:09:34 -0800 Subject: [PATCH 10/18] add spread as test --- crates/compiler/load/tests/test_reporting.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/crates/compiler/load/tests/test_reporting.rs b/crates/compiler/load/tests/test_reporting.rs index 55352fbd36..df088211c8 100644 --- a/crates/compiler/load/tests/test_reporting.rs +++ b/crates/compiler/load/tests/test_reporting.rs @@ -12637,6 +12637,19 @@ In roc, functions are always written as a lambda, like{} "### ); + test_no_problem!( + list_match_spread_as, + indoc!( + r#" + l : List [A, B] + + when l is + [A, .. as rest] | [.. as rest, A] -> rest + [.. as rest] -> rest + "# + ) + ); + test_no_problem!( list_match_exhaustive_empty_and_rest_with_unary_head, indoc!( From 2ef97fc5a15fec08ae93f93f12b4e8812c4c8dfc Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 21:09:00 -0800 Subject: [PATCH 11/18] update mono tests due to List.sublist change --- ...e_in_polymorphic_expression_issue_4717.txt | 98 +++--- .../encode_derived_nested_record_string.txt | 332 ++++++++---------- ...encode_derived_record_one_field_string.txt | 164 ++++----- ...ncode_derived_record_two_field_strings.txt | 164 ++++----- .../generated/encode_derived_string.txt | 100 +++--- .../encode_derived_tag_one_field_string.txt | 100 +++--- ...encode_derived_tag_two_payloads_string.txt | 100 +++--- .../test_mono/generated/issue_4749.txt | 148 ++++---- ..._4772_weakened_monomorphic_destructure.txt | 148 ++++---- ...not_duplicate_identical_concrete_types.txt | 100 +++--- .../weakening_avoids_overspecialization.txt | 98 +++--- 11 files changed, 706 insertions(+), 846 deletions(-) diff --git a/crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt b/crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt index 53805f7163..53d65943a3 100644 --- a/crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt +++ b/crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt @@ -1,89 +1,81 @@ procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.24; + let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.23; procedure List.26 (List.181, List.182, List.183): - let List.568 : [C U64, C U64] = CallByName List.99 List.181 List.182 List.183; - let List.571 : U8 = 1i64; - let List.572 : U8 = GetTagId List.568; - let List.573 : Int1 = lowlevel Eq List.571 List.572; - if List.573 then - let List.184 : U64 = UnionAtIndex (Id 1) (Index 0) List.568; + let List.564 : [C U64, C U64] = CallByName List.99 List.181 List.182 List.183; + let List.567 : U8 = 1i64; + let List.568 : U8 = GetTagId List.564; + let List.569 : Int1 = lowlevel Eq List.567 List.568; + if List.569 then + let List.184 : U64 = UnionAtIndex (Id 1) (Index 0) List.564; ret List.184; else - let List.185 : U64 = UnionAtIndex (Id 0) (Index 0) List.568; + let List.185 : U64 = UnionAtIndex (Id 0) (Index 0) List.564; ret List.185; procedure List.38 (List.324, List.325): - let List.567 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.567 List.325; + let List.563 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.563 List.325; let List.553 : List U8 = CallByName List.43 List.324 List.326; ret List.553; procedure List.43 (List.322, List.323): - let List.565 : U64 = CallByName List.6 List.322; - let List.564 : U64 = CallByName Num.77 List.565 List.323; - let List.555 : {U64, U64} = Struct {List.323, List.564}; + let List.561 : U64 = CallByName List.6 List.322; + let List.560 : U64 = CallByName Num.77 List.561 List.323; + let List.555 : {U64, U64} = Struct {List.323, List.560}; let List.554 : List U8 = CallByName List.49 List.322 List.555; ret List.554; procedure List.49 (List.400, List.401): - let List.562 : U64 = StructAtIndex 0 List.401; - let List.563 : U64 = 0i64; - let List.560 : Int1 = CallByName Bool.11 List.562 List.563; - if List.560 then - dec List.400; - let List.561 : List U8 = Array []; - ret List.561; - else - let List.557 : U64 = StructAtIndex 1 List.401; - let List.558 : U64 = StructAtIndex 0 List.401; - let List.556 : List U8 = CallByName List.72 List.400 List.557 List.558; - ret List.556; + let List.557 : U64 = StructAtIndex 1 List.401; + let List.558 : U64 = StructAtIndex 0 List.401; + let List.556 : List U8 = CallByName List.72 List.400 List.557 List.558; + ret List.556; procedure List.6 (#Attr.2): - let List.566 : U64 = lowlevel ListLen #Attr.2; - ret List.566; + let List.562 : U64 = lowlevel ListLen #Attr.2; + ret List.562; procedure List.66 (#Attr.2, #Attr.3): - let List.589 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.589; + let List.585 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.585; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): let List.559 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; ret List.559; procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4): - joinpoint List.577 List.471 List.472 List.473 List.474 List.475: - let List.579 : Int1 = CallByName Num.22 List.474 List.475; - if List.579 then - let List.588 : U8 = CallByName List.66 List.471 List.474; - let List.580 : [C U64, C U64] = CallByName Test.4 List.472 List.588; - let List.585 : U8 = 1i64; - let List.586 : U8 = GetTagId List.580; - let List.587 : Int1 = lowlevel Eq List.585 List.586; - if List.587 then - let List.476 : U64 = UnionAtIndex (Id 1) (Index 0) List.580; - let List.583 : U64 = 1i64; - let List.582 : U64 = CallByName Num.51 List.474 List.583; - jump List.577 List.471 List.476 List.473 List.582 List.475; + joinpoint List.573 List.471 List.472 List.473 List.474 List.475: + let List.575 : Int1 = CallByName Num.22 List.474 List.475; + if List.575 then + let List.584 : U8 = CallByName List.66 List.471 List.474; + let List.576 : [C U64, C U64] = CallByName Test.4 List.472 List.584; + let List.581 : U8 = 1i64; + let List.582 : U8 = GetTagId List.576; + let List.583 : Int1 = lowlevel Eq List.581 List.582; + if List.583 then + let List.476 : U64 = UnionAtIndex (Id 1) (Index 0) List.576; + let List.579 : U64 = 1i64; + let List.578 : U64 = CallByName Num.51 List.474 List.579; + jump List.573 List.471 List.476 List.473 List.578 List.475; else dec List.471; - let List.477 : U64 = UnionAtIndex (Id 0) (Index 0) List.580; - let List.584 : [C U64, C U64] = TagId(0) List.477; - ret List.584; + let List.477 : U64 = UnionAtIndex (Id 0) (Index 0) List.576; + let List.580 : [C U64, C U64] = TagId(0) List.477; + ret List.580; else dec List.471; - let List.578 : [C U64, C U64] = TagId(1) List.472; - ret List.578; + let List.574 : [C U64, C U64] = TagId(1) List.472; + ret List.574; in - jump List.577 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; + jump List.573 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; procedure List.99 (List.468, List.469, List.470): - let List.575 : U64 = 0i64; - let List.576 : U64 = CallByName List.6 List.468; - let List.574 : [C U64, C U64] = CallByName List.80 List.468 List.469 List.470 List.575 List.576; - ret List.574; + let List.571 : U64 = 0i64; + let List.572 : U64 = CallByName List.6 List.468; + let List.570 : [C U64, C U64] = CallByName List.80 List.468 List.469 List.470 List.571 List.572; + ret List.570; procedure Num.22 (#Attr.2, #Attr.3): let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; 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 753621fe24..d8d00be715 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 @@ -25,16 +25,12 @@ procedure #Derived.7 (#Derived.8, #Derived.9, #Derived.6): ret #Derived_gen.13; procedure Bool.1 (): - let Bool.77 : Int1 = false; - ret Bool.77; - -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.79 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.79; + let Bool.76 : Int1 = false; + ret Bool.76; procedure Bool.2 (): - let Bool.76 : Int1 = true; - ret Bool.76; + let Bool.75 : Int1 = true; + ret Bool.75; procedure Encode.23 (Encode.98): ret Encode.98; @@ -78,8 +74,8 @@ procedure Encode.26 (Encode.105, Encode.106): ret Encode.108; procedure List.13 (#Attr.2, #Attr.3): - let List.721 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; - ret List.721; + let List.713 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; + ret List.713; procedure List.18 (List.154, List.155, List.156): let List.583 : U64 = 0i64; @@ -88,196 +84,180 @@ procedure List.18 (List.154, List.155, List.156): ret List.582; procedure List.18 (List.154, List.155, List.156): - let List.655 : U64 = 0i64; - let List.656 : U64 = CallByName List.6 List.154; - let List.654 : {List U8, U64} = CallByName List.88 List.154 List.155 List.156 List.655 List.656; - ret List.654; + let List.651 : U64 = 0i64; + let List.652 : U64 = CallByName List.6 List.154; + let List.650 : {List U8, U64} = CallByName List.88 List.154 List.155 List.156 List.651 List.652; + ret List.650; procedure List.18 (List.154, List.155, List.156): - let List.667 : U64 = 0i64; - let List.668 : U64 = CallByName List.6 List.154; - let List.666 : List U8 = CallByName List.88 List.154 List.155 List.156 List.667 List.668; - ret List.666; + let List.663 : U64 = 0i64; + let List.664 : U64 = CallByName List.6 List.154; + let List.662 : List U8 = CallByName List.88 List.154 List.155 List.156 List.663 List.664; + ret List.662; procedure List.26 (List.181, List.182, List.183): - let List.738 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.741 : U8 = 1i64; - let List.742 : U8 = GetTagId List.738; - let List.743 : Int1 = lowlevel Eq List.741 List.742; - if List.743 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.738; + let List.726 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.729 : U8 = 1i64; + let List.730 : U8 = GetTagId List.726; + let List.731 : Int1 = lowlevel Eq List.729 List.730; + if List.731 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.726; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.738; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.726; ret List.185; procedure List.38 (List.324, List.325): - let List.711 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.711 List.325; - let List.710 : List Str = CallByName List.43 List.324 List.326; - ret List.710; + let List.703 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.703 List.325; + let List.702 : List Str = CallByName List.43 List.324 List.326; + ret List.702; procedure List.4 (List.119, List.120): - let List.650 : U64 = 1i64; - let List.649 : List Str = CallByName List.70 List.119 List.650; - let List.648 : List Str = CallByName List.71 List.649 List.120; - ret List.648; + let List.646 : U64 = 1i64; + let List.645 : List Str = CallByName List.70 List.119 List.646; + let List.644 : List Str = CallByName List.71 List.645 List.120; + ret List.644; procedure List.4 (List.119, List.120): - let List.653 : U64 = 1i64; - let List.652 : List U8 = CallByName List.70 List.119 List.653; - let List.651 : List U8 = CallByName List.71 List.652 List.120; - ret List.651; + let List.649 : U64 = 1i64; + let List.648 : List U8 = CallByName List.70 List.119 List.649; + let List.647 : List U8 = CallByName List.71 List.648 List.120; + ret List.647; procedure List.43 (List.322, List.323): - let List.701 : U64 = CallByName List.6 List.322; - let List.700 : U64 = CallByName Num.77 List.701 List.323; - let List.691 : {U64, U64} = Struct {List.323, List.700}; - let List.690 : List Str = CallByName List.49 List.322 List.691; - ret List.690; + let List.693 : U64 = CallByName List.6 List.322; + let List.692 : U64 = CallByName Num.77 List.693 List.323; + let List.687 : {U64, U64} = Struct {List.323, List.692}; + let List.686 : List Str = CallByName List.49 List.322 List.687; + ret List.686; procedure List.49 (List.400, List.401): - let List.698 : U64 = StructAtIndex 0 List.401; - let List.699 : U64 = 0i64; - let List.696 : Int1 = CallByName Bool.11 List.698 List.699; - if List.696 then - dec List.400; - let List.697 : List Str = Array []; - ret List.697; - else - let List.693 : U64 = StructAtIndex 1 List.401; - let List.694 : U64 = StructAtIndex 0 List.401; - let List.692 : List Str = CallByName List.72 List.400 List.693 List.694; - ret List.692; + let List.689 : U64 = StructAtIndex 1 List.401; + let List.690 : U64 = StructAtIndex 0 List.401; + let List.688 : List Str = CallByName List.72 List.400 List.689 List.690; + ret List.688; procedure List.49 (List.400, List.401): - let List.730 : U64 = StructAtIndex 0 List.401; - let List.731 : U64 = 0i64; - let List.728 : Int1 = CallByName Bool.11 List.730 List.731; - if List.728 then - dec List.400; - let List.729 : List U8 = Array []; - ret List.729; - else - let List.725 : U64 = StructAtIndex 1 List.401; - let List.726 : U64 = StructAtIndex 0 List.401; - let List.724 : List U8 = CallByName List.72 List.400 List.725 List.726; - ret List.724; + let List.717 : U64 = StructAtIndex 1 List.401; + let List.718 : U64 = StructAtIndex 0 List.401; + let List.716 : List U8 = CallByName List.72 List.400 List.717 List.718; + ret List.716; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.736 List.418: - let List.734 : U64 = 0i64; - let List.733 : {U64, U64} = Struct {List.418, List.734}; + joinpoint List.724 List.418: + let List.722 : U64 = 0i64; + let List.721 : {U64, U64} = Struct {List.418, List.722}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.733; - let List.732 : U64 = CallByName Num.75 List.417 List.418; - let List.723 : {U64, U64} = Struct {List.732, List.418}; - let List.420 : List U8 = CallByName List.49 List.415 List.723; - let List.722 : {List U8, List U8} = Struct {List.419, List.420}; - ret List.722; + let List.419 : List U8 = CallByName List.49 List.415 List.721; + let List.720 : U64 = CallByName Num.75 List.417 List.418; + let List.715 : {U64, U64} = Struct {List.720, List.418}; + let List.420 : List U8 = CallByName List.49 List.415 List.715; + let List.714 : {List U8, List U8} = Struct {List.419, List.420}; + ret List.714; in - let List.737 : Int1 = CallByName Num.24 List.417 List.416; - if List.737 then - jump List.736 List.416; + let List.725 : Int1 = CallByName Num.24 List.417 List.416; + if List.725 then + jump List.724 List.416; else - jump List.736 List.417; + jump List.724 List.417; procedure List.6 (#Attr.2): - let List.624 : U64 = lowlevel ListLen #Attr.2; - ret List.624; + let List.620 : U64 = lowlevel ListLen #Attr.2; + ret List.620; procedure List.6 (#Attr.2): - let List.717 : U64 = lowlevel ListLen #Attr.2; - ret List.717; + let List.709 : U64 = lowlevel ListLen #Attr.2; + ret List.709; procedure List.6 (#Attr.2): - let List.718 : U64 = lowlevel ListLen #Attr.2; - ret List.718; + let List.710 : U64 = lowlevel ListLen #Attr.2; + ret List.710; procedure List.6 (#Attr.2): - let List.720 : U64 = lowlevel ListLen #Attr.2; - ret List.720; + let List.712 : U64 = lowlevel ListLen #Attr.2; + ret List.712; procedure List.66 (#Attr.2, #Attr.3): let List.592 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; ret List.592; procedure List.66 (#Attr.2, #Attr.3): - let List.664 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.664; + let List.660 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.660; procedure List.66 (#Attr.2, #Attr.3): - let List.676 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let List.672 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.672; + +procedure List.68 (#Attr.2): + let List.705 : List Str = lowlevel ListWithCapacity #Attr.2; + ret List.705; + +procedure List.68 (#Attr.2): + let List.707 : List U8 = lowlevel ListWithCapacity #Attr.2; + ret List.707; + +procedure List.70 (#Attr.2, #Attr.3): + let List.626 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.626; + +procedure List.70 (#Attr.2, #Attr.3): + let List.643 : List Str = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.643; + +procedure List.71 (#Attr.2, #Attr.3): + let List.624 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.624; + +procedure List.71 (#Attr.2, #Attr.3): + let List.641 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.641; + +procedure List.72 (#Attr.2, #Attr.3, #Attr.4): + let List.691 : List Str = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; + ret List.691; + +procedure List.72 (#Attr.2, #Attr.3, #Attr.4): + let List.719 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; + ret List.719; + +procedure List.8 (#Attr.2, #Attr.3): + let List.676 : List Str = lowlevel ListConcat #Attr.2 #Attr.3; ret List.676; -procedure List.68 (#Attr.2): - let List.713 : List Str = lowlevel ListWithCapacity #Attr.2; - ret List.713; - -procedure List.68 (#Attr.2): - let List.715 : List U8 = lowlevel ListWithCapacity #Attr.2; - ret List.715; - -procedure List.70 (#Attr.2, #Attr.3): - let List.630 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.630; - -procedure List.70 (#Attr.2, #Attr.3): - let List.647 : List Str = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.647; - -procedure List.71 (#Attr.2, #Attr.3): - let List.628 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.628; - -procedure List.71 (#Attr.2, #Attr.3): - let List.645 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.645; - -procedure List.72 (#Attr.2, #Attr.3, #Attr.4): - let List.695 : List Str = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; - ret List.695; - -procedure List.72 (#Attr.2, #Attr.3, #Attr.4): - let List.727 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; - ret List.727; - procedure List.8 (#Attr.2, #Attr.3): - let List.680 : List Str = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.680; - -procedure List.8 (#Attr.2, #Attr.3): - let List.688 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.688; + let List.684 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.684; procedure List.80 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24): - joinpoint List.747 List.471 List.472 List.473 List.474 List.475: - let List.749 : Int1 = CallByName Num.22 List.474 List.475; - if List.749 then - let List.758 : U8 = CallByName List.66 List.471 List.474; - let List.750 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.758; - let List.755 : U8 = 1i64; - let List.756 : U8 = GetTagId List.750; - let List.757 : Int1 = lowlevel Eq List.755 List.756; - if List.757 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.750; - let List.753 : U64 = 1i64; - let List.752 : U64 = CallByName Num.51 List.474 List.753; - jump List.747 List.471 List.476 List.473 List.752 List.475; + joinpoint List.735 List.471 List.472 List.473 List.474 List.475: + let List.737 : Int1 = CallByName Num.22 List.474 List.475; + if List.737 then + let List.746 : U8 = CallByName List.66 List.471 List.474; + let List.738 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.746; + let List.743 : U8 = 1i64; + let List.744 : U8 = GetTagId List.738; + let List.745 : Int1 = lowlevel Eq List.743 List.744; + if List.745 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.738; + let List.741 : U64 = 1i64; + let List.740 : U64 = CallByName Num.51 List.474 List.741; + jump List.735 List.471 List.476 List.473 List.740 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.750; - let List.754 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.754; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.738; + let List.742 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.742; else dec List.471; - let List.748 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.748; + let List.736 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.736; in - jump List.747 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24; + jump List.735 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24; -procedure List.88 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32): +procedure List.88 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29): joinpoint List.585 List.157 List.158 List.159 List.160 List.161: let List.587 : Int1 = CallByName Num.22 List.160 List.161; if List.587 then @@ -291,44 +271,44 @@ procedure List.88 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_g dec List.157; ret List.158; in - jump List.585 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32; + jump List.585 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29; -procedure List.88 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44): - joinpoint List.669 List.157 List.158 List.159 List.160 List.161: - let List.671 : Int1 = CallByName Num.22 List.160 List.161; - if List.671 then - let List.675 : U8 = CallByName List.66 List.157 List.160; - let List.162 : List U8 = CallByName TotallyNotJson.215 List.158 List.675; - let List.674 : U64 = 1i64; - let List.673 : U64 = CallByName Num.51 List.160 List.674; - jump List.669 List.157 List.162 List.159 List.673 List.161; +procedure List.88 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41): + joinpoint List.653 List.157 List.158 List.159 List.160 List.161: + let List.655 : Int1 = CallByName Num.22 List.160 List.161; + if List.655 then + let List.659 : {Str, Str} = CallByName List.66 List.157 List.160; + inc List.659; + let List.162 : {List U8, U64} = CallByName TotallyNotJson.237 List.158 List.659 List.159; + let List.658 : U64 = 1i64; + let List.657 : U64 = CallByName Num.51 List.160 List.658; + jump List.653 List.157 List.162 List.159 List.657 List.161; else dec List.157; ret List.158; in - jump List.669 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44; + jump List.653 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41; -procedure List.88 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52): - joinpoint List.657 List.157 List.158 List.159 List.160 List.161: - let List.659 : Int1 = CallByName Num.22 List.160 List.161; - if List.659 then - let List.663 : {Str, Str} = CallByName List.66 List.157 List.160; - inc List.663; - let List.162 : {List U8, U64} = CallByName TotallyNotJson.237 List.158 List.663 List.159; - let List.662 : U64 = 1i64; - let List.661 : U64 = CallByName Num.51 List.160 List.662; - jump List.657 List.157 List.162 List.159 List.661 List.161; +procedure List.88 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48, #Derived_gen.49): + joinpoint List.665 List.157 List.158 List.159 List.160 List.161: + let List.667 : Int1 = CallByName Num.22 List.160 List.161; + if List.667 then + let List.671 : U8 = CallByName List.66 List.157 List.160; + let List.162 : List U8 = CallByName TotallyNotJson.215 List.158 List.671; + let List.670 : U64 = 1i64; + let List.669 : U64 = CallByName Num.51 List.160 List.670; + jump List.665 List.157 List.162 List.159 List.669 List.161; else dec List.157; ret List.158; in - jump List.657 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52; + jump List.665 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49; procedure List.99 (List.468, List.469, List.470): - let List.745 : U64 = 0i64; - let List.746 : U64 = CallByName List.6 List.468; - let List.744 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.745 List.746; - ret List.744; + let List.733 : U64 = 0i64; + let List.734 : U64 = CallByName List.6 List.468; + let List.732 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.733 List.734; + ret List.732; procedure Num.127 (#Attr.2): let Num.312 : U8 = lowlevel NumIntCast #Attr.2; @@ -1459,7 +1439,7 @@ procedure TotallyNotJson.97 (TotallyNotJson.837): dec TotallyNotJson.1567; ret TotallyNotJson.1565; -procedure TotallyNotJson.98 (#Derived_gen.39): +procedure TotallyNotJson.98 (#Derived_gen.36): joinpoint TotallyNotJson.1573 TotallyNotJson.1169: let TotallyNotJson.842 : List Str = StructAtIndex 0 TotallyNotJson.1169; let TotallyNotJson.841 : List Str = StructAtIndex 1 TotallyNotJson.1169; @@ -1497,7 +1477,7 @@ procedure TotallyNotJson.98 (#Derived_gen.39): let TotallyNotJson.1574 : {List Str, List Str} = Struct {TotallyNotJson.842, TotallyNotJson.841}; ret TotallyNotJson.1574; in - jump TotallyNotJson.1573 #Derived_gen.39; + jump TotallyNotJson.1573 #Derived_gen.36; procedure Test.0 (): let Test.12 : Str = "bar"; 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 5698df48a0..3614d098ac 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 @@ -15,10 +15,6 @@ procedure Bool.1 (): let Bool.49 : Int1 = false; ret Bool.49; -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.51 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.51; - procedure Bool.2 (): let Bool.48 : Int1 = true; ret Bool.48; @@ -51,8 +47,8 @@ procedure Encode.26 (Encode.105, Encode.106): ret Encode.108; procedure List.13 (#Attr.2, #Attr.3): - let List.649 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; - ret List.649; + let List.645 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; + ret List.645; procedure List.18 (List.154, List.155, List.156): let List.583 : U64 = 0i64; @@ -67,22 +63,22 @@ procedure List.18 (List.154, List.155, List.156): ret List.594; procedure List.26 (List.181, List.182, List.183): - let List.666 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.669 : U8 = 1i64; - let List.670 : U8 = GetTagId List.666; - let List.671 : Int1 = lowlevel Eq List.669 List.670; - if List.671 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.666; + let List.658 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.661 : U8 = 1i64; + let List.662 : U8 = GetTagId List.658; + let List.663 : Int1 = lowlevel Eq List.661 List.662; + if List.663 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.658; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.666; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.658; ret List.185; procedure List.38 (List.324, List.325): - let List.639 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.639 List.325; - let List.638 : List Str = CallByName List.43 List.324 List.326; - ret List.638; + let List.635 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.635 List.325; + let List.634 : List Str = CallByName List.43 List.324 List.326; + ret List.634; procedure List.4 (List.119, List.120): let List.578 : U64 = 1i64; @@ -97,70 +93,54 @@ procedure List.4 (List.119, List.120): ret List.579; procedure List.43 (List.322, List.323): - let List.629 : U64 = CallByName List.6 List.322; - let List.628 : U64 = CallByName Num.77 List.629 List.323; - let List.619 : {U64, U64} = Struct {List.323, List.628}; + let List.625 : U64 = CallByName List.6 List.322; + let List.624 : U64 = CallByName Num.77 List.625 List.323; + let List.619 : {U64, U64} = Struct {List.323, List.624}; let List.618 : List Str = CallByName List.49 List.322 List.619; ret List.618; procedure List.49 (List.400, List.401): - let List.626 : U64 = StructAtIndex 0 List.401; - let List.627 : U64 = 0i64; - let List.624 : Int1 = CallByName Bool.11 List.626 List.627; - if List.624 then - dec List.400; - let List.625 : List Str = Array []; - ret List.625; - else - let List.621 : U64 = StructAtIndex 1 List.401; - let List.622 : U64 = StructAtIndex 0 List.401; - let List.620 : List Str = CallByName List.72 List.400 List.621 List.622; - ret List.620; + let List.621 : U64 = StructAtIndex 1 List.401; + let List.622 : U64 = StructAtIndex 0 List.401; + let List.620 : List Str = CallByName List.72 List.400 List.621 List.622; + ret List.620; procedure List.49 (List.400, List.401): - let List.658 : U64 = StructAtIndex 0 List.401; - let List.659 : U64 = 0i64; - let List.656 : Int1 = CallByName Bool.11 List.658 List.659; - if List.656 then - dec List.400; - let List.657 : List U8 = Array []; - ret List.657; - else - let List.653 : U64 = StructAtIndex 1 List.401; - let List.654 : U64 = StructAtIndex 0 List.401; - let List.652 : List U8 = CallByName List.72 List.400 List.653 List.654; - ret List.652; + let List.649 : U64 = StructAtIndex 1 List.401; + let List.650 : U64 = StructAtIndex 0 List.401; + let List.648 : List U8 = CallByName List.72 List.400 List.649 List.650; + ret List.648; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.664 List.418: - let List.662 : U64 = 0i64; - let List.661 : {U64, U64} = Struct {List.418, List.662}; + joinpoint List.656 List.418: + let List.654 : U64 = 0i64; + let List.653 : {U64, U64} = Struct {List.418, List.654}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.661; - let List.660 : U64 = CallByName Num.75 List.417 List.418; - let List.651 : {U64, U64} = Struct {List.660, List.418}; - let List.420 : List U8 = CallByName List.49 List.415 List.651; - let List.650 : {List U8, List U8} = Struct {List.419, List.420}; - ret List.650; + let List.419 : List U8 = CallByName List.49 List.415 List.653; + let List.652 : U64 = CallByName Num.75 List.417 List.418; + let List.647 : {U64, U64} = Struct {List.652, List.418}; + let List.420 : List U8 = CallByName List.49 List.415 List.647; + let List.646 : {List U8, List U8} = Struct {List.419, List.420}; + ret List.646; in - let List.665 : Int1 = CallByName Num.24 List.417 List.416; - if List.665 then - jump List.664 List.416; + let List.657 : Int1 = CallByName Num.24 List.417 List.416; + if List.657 then + jump List.656 List.416; else - jump List.664 List.417; + jump List.656 List.417; procedure List.6 (#Attr.2): - let List.645 : U64 = lowlevel ListLen #Attr.2; - ret List.645; + let List.641 : U64 = lowlevel ListLen #Attr.2; + ret List.641; procedure List.6 (#Attr.2): - let List.646 : U64 = lowlevel ListLen #Attr.2; - ret List.646; + let List.642 : U64 = lowlevel ListLen #Attr.2; + ret List.642; procedure List.6 (#Attr.2): - let List.648 : U64 = lowlevel ListLen #Attr.2; - ret List.648; + let List.644 : U64 = lowlevel ListLen #Attr.2; + ret List.644; procedure List.66 (#Attr.2, #Attr.3): let List.592 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; @@ -171,12 +151,12 @@ procedure List.66 (#Attr.2, #Attr.3): ret List.604; procedure List.68 (#Attr.2): - let List.641 : List Str = lowlevel ListWithCapacity #Attr.2; - ret List.641; + let List.637 : List Str = lowlevel ListWithCapacity #Attr.2; + ret List.637; procedure List.68 (#Attr.2): - let List.643 : List U8 = lowlevel ListWithCapacity #Attr.2; - ret List.643; + let List.639 : List U8 = lowlevel ListWithCapacity #Attr.2; + ret List.639; procedure List.70 (#Attr.2, #Attr.3): let List.558 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; @@ -199,8 +179,8 @@ procedure List.72 (#Attr.2, #Attr.3, #Attr.4): ret List.623; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): - let List.655 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; - ret List.655; + let List.651 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; + ret List.651; procedure List.8 (#Attr.2, #Attr.3): let List.608 : List Str = lowlevel ListConcat #Attr.2 #Attr.3; @@ -211,30 +191,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.616; procedure List.80 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14): - joinpoint List.675 List.471 List.472 List.473 List.474 List.475: - let List.677 : Int1 = CallByName Num.22 List.474 List.475; - if List.677 then - let List.686 : U8 = CallByName List.66 List.471 List.474; - let List.678 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.686; - let List.683 : U8 = 1i64; - let List.684 : U8 = GetTagId List.678; - let List.685 : Int1 = lowlevel Eq List.683 List.684; - if List.685 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.678; - let List.681 : U64 = 1i64; - let List.680 : U64 = CallByName Num.51 List.474 List.681; - jump List.675 List.471 List.476 List.473 List.680 List.475; + joinpoint List.667 List.471 List.472 List.473 List.474 List.475: + let List.669 : Int1 = CallByName Num.22 List.474 List.475; + if List.669 then + let List.678 : U8 = CallByName List.66 List.471 List.474; + let List.670 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.678; + let List.675 : U8 = 1i64; + let List.676 : U8 = GetTagId List.670; + let List.677 : Int1 = lowlevel Eq List.675 List.676; + if List.677 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.670; + let List.673 : U64 = 1i64; + let List.672 : U64 = CallByName Num.51 List.474 List.673; + jump List.667 List.471 List.476 List.473 List.672 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.678; - let List.682 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.682; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.670; + let List.674 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.674; else dec List.471; - let List.676 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.676; + let List.668 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.668; in - jump List.675 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14; + jump List.667 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14; procedure List.88 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20): joinpoint List.585 List.157 List.158 List.159 List.160 List.161: @@ -268,10 +248,10 @@ procedure List.88 (#Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_g jump List.597 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35; procedure List.99 (List.468, List.469, List.470): - let List.673 : U64 = 0i64; - let List.674 : U64 = CallByName List.6 List.468; - let List.672 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.673 List.674; - ret List.672; + let List.665 : U64 = 0i64; + let List.666 : U64 = CallByName List.6 List.468; + let List.664 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.665 List.666; + ret List.664; procedure Num.127 (#Attr.2): let Num.296 : U8 = lowlevel NumIntCast #Attr.2; 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 ac3b7d85b5..0d290184f8 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 @@ -22,10 +22,6 @@ procedure Bool.1 (): let Bool.49 : Int1 = false; ret Bool.49; -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.51 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.51; - procedure Bool.2 (): let Bool.48 : Int1 = true; ret Bool.48; @@ -58,8 +54,8 @@ procedure Encode.26 (Encode.105, Encode.106): ret Encode.108; procedure List.13 (#Attr.2, #Attr.3): - let List.649 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; - ret List.649; + let List.645 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3; + ret List.645; procedure List.18 (List.154, List.155, List.156): let List.583 : U64 = 0i64; @@ -74,22 +70,22 @@ procedure List.18 (List.154, List.155, List.156): ret List.594; procedure List.26 (List.181, List.182, List.183): - let List.666 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.669 : U8 = 1i64; - let List.670 : U8 = GetTagId List.666; - let List.671 : Int1 = lowlevel Eq List.669 List.670; - if List.671 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.666; + let List.658 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.661 : U8 = 1i64; + let List.662 : U8 = GetTagId List.658; + let List.663 : Int1 = lowlevel Eq List.661 List.662; + if List.663 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.658; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.666; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.658; ret List.185; procedure List.38 (List.324, List.325): - let List.639 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.639 List.325; - let List.638 : List Str = CallByName List.43 List.324 List.326; - ret List.638; + let List.635 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.635 List.325; + let List.634 : List Str = CallByName List.43 List.324 List.326; + ret List.634; procedure List.4 (List.119, List.120): let List.578 : U64 = 1i64; @@ -104,70 +100,54 @@ procedure List.4 (List.119, List.120): ret List.579; procedure List.43 (List.322, List.323): - let List.629 : U64 = CallByName List.6 List.322; - let List.628 : U64 = CallByName Num.77 List.629 List.323; - let List.619 : {U64, U64} = Struct {List.323, List.628}; + let List.625 : U64 = CallByName List.6 List.322; + let List.624 : U64 = CallByName Num.77 List.625 List.323; + let List.619 : {U64, U64} = Struct {List.323, List.624}; let List.618 : List Str = CallByName List.49 List.322 List.619; ret List.618; procedure List.49 (List.400, List.401): - let List.626 : U64 = StructAtIndex 0 List.401; - let List.627 : U64 = 0i64; - let List.624 : Int1 = CallByName Bool.11 List.626 List.627; - if List.624 then - dec List.400; - let List.625 : List Str = Array []; - ret List.625; - else - let List.621 : U64 = StructAtIndex 1 List.401; - let List.622 : U64 = StructAtIndex 0 List.401; - let List.620 : List Str = CallByName List.72 List.400 List.621 List.622; - ret List.620; + let List.621 : U64 = StructAtIndex 1 List.401; + let List.622 : U64 = StructAtIndex 0 List.401; + let List.620 : List Str = CallByName List.72 List.400 List.621 List.622; + ret List.620; procedure List.49 (List.400, List.401): - let List.658 : U64 = StructAtIndex 0 List.401; - let List.659 : U64 = 0i64; - let List.656 : Int1 = CallByName Bool.11 List.658 List.659; - if List.656 then - dec List.400; - let List.657 : List U8 = Array []; - ret List.657; - else - let List.653 : U64 = StructAtIndex 1 List.401; - let List.654 : U64 = StructAtIndex 0 List.401; - let List.652 : List U8 = CallByName List.72 List.400 List.653 List.654; - ret List.652; + let List.649 : U64 = StructAtIndex 1 List.401; + let List.650 : U64 = StructAtIndex 0 List.401; + let List.648 : List U8 = CallByName List.72 List.400 List.649 List.650; + ret List.648; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.664 List.418: - let List.662 : U64 = 0i64; - let List.661 : {U64, U64} = Struct {List.418, List.662}; + joinpoint List.656 List.418: + let List.654 : U64 = 0i64; + let List.653 : {U64, U64} = Struct {List.418, List.654}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.661; - let List.660 : U64 = CallByName Num.75 List.417 List.418; - let List.651 : {U64, U64} = Struct {List.660, List.418}; - let List.420 : List U8 = CallByName List.49 List.415 List.651; - let List.650 : {List U8, List U8} = Struct {List.419, List.420}; - ret List.650; + let List.419 : List U8 = CallByName List.49 List.415 List.653; + let List.652 : U64 = CallByName Num.75 List.417 List.418; + let List.647 : {U64, U64} = Struct {List.652, List.418}; + let List.420 : List U8 = CallByName List.49 List.415 List.647; + let List.646 : {List U8, List U8} = Struct {List.419, List.420}; + ret List.646; in - let List.665 : Int1 = CallByName Num.24 List.417 List.416; - if List.665 then - jump List.664 List.416; + let List.657 : Int1 = CallByName Num.24 List.417 List.416; + if List.657 then + jump List.656 List.416; else - jump List.664 List.417; + jump List.656 List.417; procedure List.6 (#Attr.2): - let List.645 : U64 = lowlevel ListLen #Attr.2; - ret List.645; + let List.641 : U64 = lowlevel ListLen #Attr.2; + ret List.641; procedure List.6 (#Attr.2): - let List.646 : U64 = lowlevel ListLen #Attr.2; - ret List.646; + let List.642 : U64 = lowlevel ListLen #Attr.2; + ret List.642; procedure List.6 (#Attr.2): - let List.648 : U64 = lowlevel ListLen #Attr.2; - ret List.648; + let List.644 : U64 = lowlevel ListLen #Attr.2; + ret List.644; procedure List.66 (#Attr.2, #Attr.3): let List.592 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; @@ -178,12 +158,12 @@ procedure List.66 (#Attr.2, #Attr.3): ret List.604; procedure List.68 (#Attr.2): - let List.641 : List Str = lowlevel ListWithCapacity #Attr.2; - ret List.641; + let List.637 : List Str = lowlevel ListWithCapacity #Attr.2; + ret List.637; procedure List.68 (#Attr.2): - let List.643 : List U8 = lowlevel ListWithCapacity #Attr.2; - ret List.643; + let List.639 : List U8 = lowlevel ListWithCapacity #Attr.2; + ret List.639; procedure List.70 (#Attr.2, #Attr.3): let List.558 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; @@ -206,8 +186,8 @@ procedure List.72 (#Attr.2, #Attr.3, #Attr.4): ret List.623; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): - let List.655 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; - ret List.655; + let List.651 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; + ret List.651; procedure List.8 (#Attr.2, #Attr.3): let List.608 : List Str = lowlevel ListConcat #Attr.2 #Attr.3; @@ -218,30 +198,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.616; procedure List.80 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18): - joinpoint List.675 List.471 List.472 List.473 List.474 List.475: - let List.677 : Int1 = CallByName Num.22 List.474 List.475; - if List.677 then - let List.686 : U8 = CallByName List.66 List.471 List.474; - let List.678 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.686; - let List.683 : U8 = 1i64; - let List.684 : U8 = GetTagId List.678; - let List.685 : Int1 = lowlevel Eq List.683 List.684; - if List.685 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.678; - let List.681 : U64 = 1i64; - let List.680 : U64 = CallByName Num.51 List.474 List.681; - jump List.675 List.471 List.476 List.473 List.680 List.475; + joinpoint List.667 List.471 List.472 List.473 List.474 List.475: + let List.669 : Int1 = CallByName Num.22 List.474 List.475; + if List.669 then + let List.678 : U8 = CallByName List.66 List.471 List.474; + let List.670 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.678; + let List.675 : U8 = 1i64; + let List.676 : U8 = GetTagId List.670; + let List.677 : Int1 = lowlevel Eq List.675 List.676; + if List.677 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.670; + let List.673 : U64 = 1i64; + let List.672 : U64 = CallByName Num.51 List.474 List.673; + jump List.667 List.471 List.476 List.473 List.672 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.678; - let List.682 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.682; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.670; + let List.674 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.674; else dec List.471; - let List.676 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.676; + let List.668 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.668; in - jump List.675 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18; + jump List.667 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18; procedure List.88 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24): joinpoint List.585 List.157 List.158 List.159 List.160 List.161: @@ -275,10 +255,10 @@ procedure List.88 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_g jump List.597 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39; procedure List.99 (List.468, List.469, List.470): - let List.673 : U64 = 0i64; - let List.674 : U64 = CallByName List.6 List.468; - let List.672 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.673 List.674; - ret List.672; + let List.665 : U64 = 0i64; + let List.666 : U64 = CallByName List.6 List.468; + let List.664 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.665 List.666; + ret List.664; procedure Num.127 (#Attr.2): let Num.296 : U8 = lowlevel NumIntCast #Attr.2; diff --git a/crates/compiler/test_mono/generated/encode_derived_string.txt b/crates/compiler/test_mono/generated/encode_derived_string.txt index 98bb86a7d4..faba9cdacc 100644 --- a/crates/compiler/test_mono/generated/encode_derived_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_string.txt @@ -1,7 +1,3 @@ -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.23; - procedure Encode.23 (Encode.98): ret Encode.98; @@ -22,49 +18,41 @@ procedure List.18 (List.154, List.155, List.156): ret List.566; procedure List.26 (List.181, List.182, List.183): - let List.593 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.596 : U8 = 1i64; - let List.597 : U8 = GetTagId List.593; - let List.598 : Int1 = lowlevel Eq List.596 List.597; - if List.598 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.593; + let List.589 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.592 : U8 = 1i64; + let List.593 : U8 = GetTagId List.589; + let List.594 : Int1 = lowlevel Eq List.592 List.593; + if List.594 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.589; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.593; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.589; ret List.185; procedure List.49 (List.400, List.401): - let List.585 : U64 = StructAtIndex 0 List.401; - let List.586 : U64 = 0i64; - let List.583 : Int1 = CallByName Bool.11 List.585 List.586; - if List.583 then - dec List.400; - let List.584 : List U8 = Array []; - ret List.584; - else - let List.580 : U64 = StructAtIndex 1 List.401; - let List.581 : U64 = StructAtIndex 0 List.401; - let List.579 : List U8 = CallByName List.72 List.400 List.580 List.581; - ret List.579; + let List.580 : U64 = StructAtIndex 1 List.401; + let List.581 : U64 = StructAtIndex 0 List.401; + let List.579 : List U8 = CallByName List.72 List.400 List.580 List.581; + ret List.579; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.591 List.418: - let List.589 : U64 = 0i64; - let List.588 : {U64, U64} = Struct {List.418, List.589}; + joinpoint List.587 List.418: + let List.585 : U64 = 0i64; + let List.584 : {U64, U64} = Struct {List.418, List.585}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.588; - let List.587 : U64 = CallByName Num.75 List.417 List.418; - let List.578 : {U64, U64} = Struct {List.587, List.418}; + let List.419 : List U8 = CallByName List.49 List.415 List.584; + let List.583 : U64 = CallByName Num.75 List.417 List.418; + let List.578 : {U64, U64} = Struct {List.583, List.418}; let List.420 : List U8 = CallByName List.49 List.415 List.578; let List.577 : {List U8, List U8} = Struct {List.419, List.420}; ret List.577; in - let List.592 : Int1 = CallByName Num.24 List.417 List.416; - if List.592 then - jump List.591 List.416; + let List.588 : Int1 = CallByName Num.24 List.417 List.416; + if List.588 then + jump List.587 List.416; else - jump List.591 List.417; + jump List.587 List.417; procedure List.6 (#Attr.2): let List.565 : U64 = lowlevel ListLen #Attr.2; @@ -87,30 +75,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.561; procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12): - joinpoint List.602 List.471 List.472 List.473 List.474 List.475: - let List.604 : Int1 = CallByName Num.22 List.474 List.475; - if List.604 then - let List.613 : U8 = CallByName List.66 List.471 List.474; - let List.605 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.613; - let List.610 : U8 = 1i64; - let List.611 : U8 = GetTagId List.605; - let List.612 : Int1 = lowlevel Eq List.610 List.611; - if List.612 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.605; - let List.608 : U64 = 1i64; - let List.607 : U64 = CallByName Num.51 List.474 List.608; - jump List.602 List.471 List.476 List.473 List.607 List.475; + joinpoint List.598 List.471 List.472 List.473 List.474 List.475: + let List.600 : Int1 = CallByName Num.22 List.474 List.475; + if List.600 then + let List.609 : U8 = CallByName List.66 List.471 List.474; + let List.601 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.609; + let List.606 : U8 = 1i64; + let List.607 : U8 = GetTagId List.601; + let List.608 : Int1 = lowlevel Eq List.606 List.607; + if List.608 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.601; + let List.604 : U64 = 1i64; + let List.603 : U64 = CallByName Num.51 List.474 List.604; + jump List.598 List.471 List.476 List.473 List.603 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.605; - let List.609 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.609; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.601; + let List.605 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.605; else dec List.471; - let List.603 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.603; + let List.599 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.599; in - jump List.602 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12; + jump List.598 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12; procedure List.88 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4): joinpoint List.569 List.157 List.158 List.159 List.160 List.161: @@ -128,10 +116,10 @@ procedure List.88 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen. jump List.569 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; procedure List.99 (List.468, List.469, List.470): - let List.600 : U64 = 0i64; - let List.601 : U64 = CallByName List.6 List.468; - let List.599 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.600 List.601; - ret List.599; + let List.596 : U64 = 0i64; + let List.597 : U64 = CallByName List.6 List.468; + let List.595 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.596 List.597; + ret List.595; procedure Num.19 (#Attr.2, #Attr.3): let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; 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 ebbb5bf8b4..62a1aa5f46 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 @@ -13,10 +13,6 @@ procedure #Derived.3 (#Derived.4, #Derived.5, #Derived.1): let #Derived_gen.6 : {Str, List Str} = CallByName TotallyNotJson.32 #Derived_gen.7 #Derived_gen.8; jump #Derived_gen.5 #Derived_gen.6; -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.23; - procedure Encode.23 (Encode.98): ret Encode.98; @@ -57,15 +53,15 @@ procedure List.18 (List.154, List.155, List.156): ret List.592; procedure List.26 (List.181, List.182, List.183): - let List.634 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.637 : U8 = 1i64; - let List.638 : U8 = GetTagId List.634; - let List.639 : Int1 = lowlevel Eq List.637 List.638; - if List.639 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.634; + let List.630 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.633 : U8 = 1i64; + let List.634 : U8 = GetTagId List.630; + let List.635 : Int1 = lowlevel Eq List.633 List.634; + if List.635 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.630; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.634; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.630; ret List.185; procedure List.4 (List.119, List.120): @@ -75,37 +71,29 @@ procedure List.4 (List.119, List.120): ret List.577; procedure List.49 (List.400, List.401): - let List.626 : U64 = StructAtIndex 0 List.401; - let List.627 : U64 = 0i64; - let List.624 : Int1 = CallByName Bool.11 List.626 List.627; - if List.624 then - dec List.400; - let List.625 : List U8 = Array []; - ret List.625; - else - let List.621 : U64 = StructAtIndex 1 List.401; - let List.622 : U64 = StructAtIndex 0 List.401; - let List.620 : List U8 = CallByName List.72 List.400 List.621 List.622; - ret List.620; + let List.621 : U64 = StructAtIndex 1 List.401; + let List.622 : U64 = StructAtIndex 0 List.401; + let List.620 : List U8 = CallByName List.72 List.400 List.621 List.622; + ret List.620; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.632 List.418: - let List.630 : U64 = 0i64; - let List.629 : {U64, U64} = Struct {List.418, List.630}; + joinpoint List.628 List.418: + let List.626 : U64 = 0i64; + let List.625 : {U64, U64} = Struct {List.418, List.626}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.629; - let List.628 : U64 = CallByName Num.75 List.417 List.418; - let List.619 : {U64, U64} = Struct {List.628, List.418}; + let List.419 : List U8 = CallByName List.49 List.415 List.625; + let List.624 : U64 = CallByName Num.75 List.417 List.418; + let List.619 : {U64, U64} = Struct {List.624, List.418}; let List.420 : List U8 = CallByName List.49 List.415 List.619; let List.618 : {List U8, List U8} = Struct {List.419, List.420}; ret List.618; in - let List.633 : Int1 = CallByName Num.24 List.417 List.416; - if List.633 then - jump List.632 List.416; + let List.629 : Int1 = CallByName Num.24 List.417 List.416; + if List.629 then + jump List.628 List.416; else - jump List.632 List.417; + jump List.628 List.417; procedure List.6 (#Attr.2): let List.604 : U64 = lowlevel ListLen #Attr.2; @@ -144,30 +132,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.615; procedure List.80 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30): - joinpoint List.643 List.471 List.472 List.473 List.474 List.475: - let List.645 : Int1 = CallByName Num.22 List.474 List.475; - if List.645 then - let List.654 : U8 = CallByName List.66 List.471 List.474; - let List.646 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.654; - let List.651 : U8 = 1i64; - let List.652 : U8 = GetTagId List.646; - let List.653 : Int1 = lowlevel Eq List.651 List.652; - if List.653 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.646; - let List.649 : U64 = 1i64; - let List.648 : U64 = CallByName Num.51 List.474 List.649; - jump List.643 List.471 List.476 List.473 List.648 List.475; + joinpoint List.639 List.471 List.472 List.473 List.474 List.475: + let List.641 : Int1 = CallByName Num.22 List.474 List.475; + if List.641 then + let List.650 : U8 = CallByName List.66 List.471 List.474; + let List.642 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.650; + let List.647 : U8 = 1i64; + let List.648 : U8 = GetTagId List.642; + let List.649 : Int1 = lowlevel Eq List.647 List.648; + if List.649 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.642; + let List.645 : U64 = 1i64; + let List.644 : U64 = CallByName Num.51 List.474 List.645; + jump List.639 List.471 List.476 List.473 List.644 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.646; - let List.650 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.650; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.642; + let List.646 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.646; else dec List.471; - let List.644 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.644; + let List.640 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.640; in - jump List.643 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30; + jump List.639 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30; procedure List.88 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14): joinpoint List.583 List.157 List.158 List.159 List.160 List.161: @@ -201,10 +189,10 @@ procedure List.88 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_g jump List.595 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25; procedure List.99 (List.468, List.469, List.470): - let List.641 : U64 = 0i64; - let List.642 : U64 = CallByName List.6 List.468; - let List.640 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.641 List.642; - ret List.640; + let List.637 : U64 = 0i64; + let List.638 : U64 = CallByName List.6 List.468; + let List.636 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.637 List.638; + ret List.636; procedure Num.127 (#Attr.2): let Num.298 : U8 = lowlevel NumIntCast #Attr.2; 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 628bbe1940..afbbc21779 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 @@ -16,10 +16,6 @@ procedure #Derived.4 (#Derived.5, #Derived.6, #Derived.1): let #Derived_gen.6 : {Str, List Str} = CallByName TotallyNotJson.32 #Derived_gen.7 #Derived_gen.8; jump #Derived_gen.5 #Derived_gen.6; -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.23; - procedure Encode.23 (Encode.98): ret Encode.98; @@ -60,15 +56,15 @@ procedure List.18 (List.154, List.155, List.156): ret List.592; procedure List.26 (List.181, List.182, List.183): - let List.634 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.637 : U8 = 1i64; - let List.638 : U8 = GetTagId List.634; - let List.639 : Int1 = lowlevel Eq List.637 List.638; - if List.639 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.634; + let List.630 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.633 : U8 = 1i64; + let List.634 : U8 = GetTagId List.630; + let List.635 : Int1 = lowlevel Eq List.633 List.634; + if List.635 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.630; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.634; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.630; ret List.185; procedure List.4 (List.119, List.120): @@ -78,37 +74,29 @@ procedure List.4 (List.119, List.120): ret List.577; procedure List.49 (List.400, List.401): - let List.626 : U64 = StructAtIndex 0 List.401; - let List.627 : U64 = 0i64; - let List.624 : Int1 = CallByName Bool.11 List.626 List.627; - if List.624 then - dec List.400; - let List.625 : List U8 = Array []; - ret List.625; - else - let List.621 : U64 = StructAtIndex 1 List.401; - let List.622 : U64 = StructAtIndex 0 List.401; - let List.620 : List U8 = CallByName List.72 List.400 List.621 List.622; - ret List.620; + let List.621 : U64 = StructAtIndex 1 List.401; + let List.622 : U64 = StructAtIndex 0 List.401; + let List.620 : List U8 = CallByName List.72 List.400 List.621 List.622; + ret List.620; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.632 List.418: - let List.630 : U64 = 0i64; - let List.629 : {U64, U64} = Struct {List.418, List.630}; + joinpoint List.628 List.418: + let List.626 : U64 = 0i64; + let List.625 : {U64, U64} = Struct {List.418, List.626}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.629; - let List.628 : U64 = CallByName Num.75 List.417 List.418; - let List.619 : {U64, U64} = Struct {List.628, List.418}; + let List.419 : List U8 = CallByName List.49 List.415 List.625; + let List.624 : U64 = CallByName Num.75 List.417 List.418; + let List.619 : {U64, U64} = Struct {List.624, List.418}; let List.420 : List U8 = CallByName List.49 List.415 List.619; let List.618 : {List U8, List U8} = Struct {List.419, List.420}; ret List.618; in - let List.633 : Int1 = CallByName Num.24 List.417 List.416; - if List.633 then - jump List.632 List.416; + let List.629 : Int1 = CallByName Num.24 List.417 List.416; + if List.629 then + jump List.628 List.416; else - jump List.632 List.417; + jump List.628 List.417; procedure List.6 (#Attr.2): let List.604 : U64 = lowlevel ListLen #Attr.2; @@ -147,30 +135,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.615; procedure List.80 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23): - joinpoint List.643 List.471 List.472 List.473 List.474 List.475: - let List.645 : Int1 = CallByName Num.22 List.474 List.475; - if List.645 then - let List.654 : U8 = CallByName List.66 List.471 List.474; - let List.646 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.654; - let List.651 : U8 = 1i64; - let List.652 : U8 = GetTagId List.646; - let List.653 : Int1 = lowlevel Eq List.651 List.652; - if List.653 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.646; - let List.649 : U64 = 1i64; - let List.648 : U64 = CallByName Num.51 List.474 List.649; - jump List.643 List.471 List.476 List.473 List.648 List.475; + joinpoint List.639 List.471 List.472 List.473 List.474 List.475: + let List.641 : Int1 = CallByName Num.22 List.474 List.475; + if List.641 then + let List.650 : U8 = CallByName List.66 List.471 List.474; + let List.642 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.650; + let List.647 : U8 = 1i64; + let List.648 : U8 = GetTagId List.642; + let List.649 : Int1 = lowlevel Eq List.647 List.648; + if List.649 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.642; + let List.645 : U64 = 1i64; + let List.644 : U64 = CallByName Num.51 List.474 List.645; + jump List.639 List.471 List.476 List.473 List.644 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.646; - let List.650 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.650; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.642; + let List.646 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.646; else dec List.471; - let List.644 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.644; + let List.640 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.640; in - jump List.643 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23; + jump List.639 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23; procedure List.88 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): joinpoint List.595 List.157 List.158 List.159 List.160 List.161: @@ -204,10 +192,10 @@ procedure List.88 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_g jump List.583 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31; procedure List.99 (List.468, List.469, List.470): - let List.641 : U64 = 0i64; - let List.642 : U64 = CallByName List.6 List.468; - let List.640 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.641 List.642; - ret List.640; + let List.637 : U64 = 0i64; + let List.638 : U64 = CallByName List.6 List.468; + let List.636 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.637 List.638; + ret List.636; procedure Num.127 (#Attr.2): let Num.298 : U8 = lowlevel NumIntCast #Attr.2; diff --git a/crates/compiler/test_mono/generated/issue_4749.txt b/crates/compiler/test_mono/generated/issue_4749.txt index 09245badf7..d72ad5c1a0 100644 --- a/crates/compiler/test_mono/generated/issue_4749.txt +++ b/crates/compiler/test_mono/generated/issue_4749.txt @@ -11,8 +11,8 @@ procedure Bool.11 (#Attr.2, #Attr.3): ret Bool.42; procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.57 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.57; + let Bool.54 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.54; procedure Bool.2 (): let Bool.50 : Int1 = true; @@ -65,126 +65,118 @@ procedure Decode.27 (Decode.107, Decode.108): ret Decode.123; procedure List.1 (List.102): - let List.619 : U64 = CallByName List.6 List.102; + let List.607 : U64 = CallByName List.6 List.102; dec List.102; - let List.620 : U64 = 0i64; - let List.618 : Int1 = CallByName Bool.11 List.619 List.620; - ret List.618; + let List.608 : U64 = 0i64; + let List.606 : Int1 = CallByName Bool.11 List.607 List.608; + ret List.606; procedure List.2 (List.103, List.104): - let List.602 : U64 = CallByName List.6 List.103; - let List.599 : Int1 = CallByName Num.22 List.104 List.602; - if List.599 then - let List.601 : U8 = CallByName List.66 List.103 List.104; + let List.598 : U64 = CallByName List.6 List.103; + let List.595 : Int1 = CallByName Num.22 List.104 List.598; + if List.595 then + let List.597 : U8 = CallByName List.66 List.103 List.104; dec List.103; - let List.600 : [C {}, C U8] = TagId(1) List.601; - ret List.600; + let List.596 : [C {}, C U8] = TagId(1) List.597; + ret List.596; else dec List.103; - let List.598 : {} = Struct {}; - let List.597 : [C {}, C U8] = TagId(0) List.598; - ret List.597; + let List.594 : {} = Struct {}; + let List.593 : [C {}, C U8] = TagId(0) List.594; + ret List.593; procedure List.26 (List.181, List.182, List.183): - let List.621 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.99 List.181 List.182 List.183; - let List.624 : U8 = 1i64; - let List.625 : U8 = GetTagId List.621; - let List.626 : Int1 = lowlevel Eq List.624 List.625; - if List.626 then - let List.184 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.621; + let List.609 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.99 List.181 List.182 List.183; + let List.612 : U8 = 1i64; + let List.613 : U8 = GetTagId List.609; + let List.614 : Int1 = lowlevel Eq List.612 List.613; + if List.614 then + let List.184 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.609; ret List.184; else - let List.185 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.621; + let List.185 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.609; ret List.185; procedure List.38 (List.324, List.325): - let List.579 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.579 List.325; - let List.578 : List U8 = CallByName List.43 List.324 List.326; - ret List.578; + let List.575 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.575 List.325; + let List.574 : List U8 = CallByName List.43 List.324 List.326; + ret List.574; procedure List.4 (List.119, List.120): - let List.589 : U64 = 1i64; - let List.588 : List U8 = CallByName List.70 List.119 List.589; - let List.587 : List U8 = CallByName List.71 List.588 List.120; - ret List.587; + let List.585 : U64 = 1i64; + let List.584 : List U8 = CallByName List.70 List.119 List.585; + let List.583 : List U8 = CallByName List.71 List.584 List.120; + ret List.583; procedure List.43 (List.322, List.323): - let List.569 : U64 = CallByName List.6 List.322; - let List.568 : U64 = CallByName Num.77 List.569 List.323; - let List.559 : {U64, U64} = Struct {List.323, List.568}; + let List.565 : U64 = CallByName List.6 List.322; + let List.564 : U64 = CallByName Num.77 List.565 List.323; + let List.559 : {U64, U64} = Struct {List.323, List.564}; let List.558 : List U8 = CallByName List.49 List.322 List.559; ret List.558; procedure List.49 (List.400, List.401): - let List.615 : U64 = StructAtIndex 0 List.401; - let List.616 : U64 = 0i64; - let List.613 : Int1 = CallByName Bool.11 List.615 List.616; - if List.613 then - dec List.400; - let List.614 : List U8 = Array []; - ret List.614; - else - let List.611 : U64 = StructAtIndex 1 List.401; - let List.612 : U64 = StructAtIndex 0 List.401; - let List.610 : List U8 = CallByName List.72 List.400 List.611 List.612; - ret List.610; + let List.603 : U64 = StructAtIndex 1 List.401; + let List.604 : U64 = StructAtIndex 0 List.401; + let List.602 : List U8 = CallByName List.72 List.400 List.603 List.604; + ret List.602; procedure List.6 (#Attr.2): - let List.642 : U64 = lowlevel ListLen #Attr.2; - ret List.642; + let List.630 : U64 = lowlevel ListLen #Attr.2; + ret List.630; procedure List.66 (#Attr.2, #Attr.3): - let List.595 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.595; + let List.591 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.591; procedure List.70 (#Attr.2, #Attr.3): - let List.586 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.586; + let List.582 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.582; procedure List.71 (#Attr.2, #Attr.3): - let List.584 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.584; + let List.580 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.580; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): let List.563 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; ret List.563; procedure List.8 (#Attr.2, #Attr.3): - let List.581 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.581; + let List.577 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.577; procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5): - joinpoint List.630 List.471 List.472 List.473 List.474 List.475: - let List.632 : Int1 = CallByName Num.22 List.474 List.475; - if List.632 then - let List.641 : U8 = CallByName List.66 List.471 List.474; - let List.633 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.472 List.641; - let List.638 : U8 = 1i64; - let List.639 : U8 = GetTagId List.633; - let List.640 : Int1 = lowlevel Eq List.638 List.639; - if List.640 then - let List.476 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.633; - let List.636 : U64 = 1i64; - let List.635 : U64 = CallByName Num.51 List.474 List.636; - jump List.630 List.471 List.476 List.473 List.635 List.475; + joinpoint List.618 List.471 List.472 List.473 List.474 List.475: + let List.620 : Int1 = CallByName Num.22 List.474 List.475; + if List.620 then + let List.629 : U8 = CallByName List.66 List.471 List.474; + let List.621 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.472 List.629; + let List.626 : U8 = 1i64; + let List.627 : U8 = GetTagId List.621; + let List.628 : Int1 = lowlevel Eq List.626 List.627; + if List.628 then + let List.476 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.621; + let List.624 : U64 = 1i64; + let List.623 : U64 = CallByName Num.51 List.474 List.624; + jump List.618 List.471 List.476 List.473 List.623 List.475; else dec List.471; - let List.477 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.633; - let List.637 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.477; - ret List.637; + let List.477 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.621; + let List.625 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.477; + ret List.625; else dec List.471; - let List.631 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.472; - ret List.631; + let List.619 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.472; + ret List.619; in - jump List.630 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5; + jump List.618 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5; procedure List.99 (List.468, List.469, List.470): - let List.628 : U64 = 0i64; - let List.629 : U64 = CallByName List.6 List.468; - let List.627 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.468 List.469 List.470 List.628 List.629; - ret List.627; + let List.616 : U64 = 0i64; + let List.617 : U64 = CallByName List.6 List.468; + let List.615 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.468 List.469 List.470 List.616 List.617; + ret List.615; procedure Num.19 (#Attr.2, #Attr.3): let Num.294 : U8 = lowlevel NumAdd #Attr.2 #Attr.3; diff --git a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt index f3ca3911ae..0d16b9f45a 100644 --- a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt +++ b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt @@ -11,8 +11,8 @@ procedure Bool.11 (#Attr.2, #Attr.3): ret Bool.42; procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.57 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.57; + let Bool.54 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.54; procedure Bool.2 (): let Bool.50 : Int1 = true; @@ -39,126 +39,118 @@ procedure Decode.26 (Decode.105, Decode.106): ret Decode.122; procedure List.1 (List.102): - let List.615 : U64 = CallByName List.6 List.102; + let List.603 : U64 = CallByName List.6 List.102; dec List.102; - let List.616 : U64 = 0i64; - let List.614 : Int1 = CallByName Bool.11 List.615 List.616; - ret List.614; + let List.604 : U64 = 0i64; + let List.602 : Int1 = CallByName Bool.11 List.603 List.604; + ret List.602; procedure List.2 (List.103, List.104): - let List.598 : U64 = CallByName List.6 List.103; - let List.595 : Int1 = CallByName Num.22 List.104 List.598; - if List.595 then - let List.597 : U8 = CallByName List.66 List.103 List.104; + let List.594 : U64 = CallByName List.6 List.103; + let List.591 : Int1 = CallByName Num.22 List.104 List.594; + if List.591 then + let List.593 : U8 = CallByName List.66 List.103 List.104; dec List.103; - let List.596 : [C {}, C U8] = TagId(1) List.597; - ret List.596; + let List.592 : [C {}, C U8] = TagId(1) List.593; + ret List.592; else dec List.103; - let List.594 : {} = Struct {}; - let List.593 : [C {}, C U8] = TagId(0) List.594; - ret List.593; + let List.590 : {} = Struct {}; + let List.589 : [C {}, C U8] = TagId(0) List.590; + ret List.589; procedure List.26 (List.181, List.182, List.183): - let List.617 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.99 List.181 List.182 List.183; - let List.620 : U8 = 1i64; - let List.621 : U8 = GetTagId List.617; - let List.622 : Int1 = lowlevel Eq List.620 List.621; - if List.622 then - let List.184 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.617; + let List.605 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.99 List.181 List.182 List.183; + let List.608 : U8 = 1i64; + let List.609 : U8 = GetTagId List.605; + let List.610 : Int1 = lowlevel Eq List.608 List.609; + if List.610 then + let List.184 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.605; ret List.184; else - let List.185 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.617; + let List.185 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.605; ret List.185; procedure List.38 (List.324, List.325): - let List.575 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.575 List.325; - let List.574 : List U8 = CallByName List.43 List.324 List.326; - ret List.574; + let List.571 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.571 List.325; + let List.570 : List U8 = CallByName List.43 List.324 List.326; + ret List.570; procedure List.4 (List.119, List.120): - let List.585 : U64 = 1i64; - let List.584 : List U8 = CallByName List.70 List.119 List.585; - let List.583 : List U8 = CallByName List.71 List.584 List.120; - ret List.583; + let List.581 : U64 = 1i64; + let List.580 : List U8 = CallByName List.70 List.119 List.581; + let List.579 : List U8 = CallByName List.71 List.580 List.120; + ret List.579; procedure List.43 (List.322, List.323): - let List.565 : U64 = CallByName List.6 List.322; - let List.564 : U64 = CallByName Num.77 List.565 List.323; - let List.555 : {U64, U64} = Struct {List.323, List.564}; + let List.561 : U64 = CallByName List.6 List.322; + let List.560 : U64 = CallByName Num.77 List.561 List.323; + let List.555 : {U64, U64} = Struct {List.323, List.560}; let List.554 : List U8 = CallByName List.49 List.322 List.555; ret List.554; procedure List.49 (List.400, List.401): - let List.611 : U64 = StructAtIndex 0 List.401; - let List.612 : U64 = 0i64; - let List.609 : Int1 = CallByName Bool.11 List.611 List.612; - if List.609 then - dec List.400; - let List.610 : List U8 = Array []; - ret List.610; - else - let List.607 : U64 = StructAtIndex 1 List.401; - let List.608 : U64 = StructAtIndex 0 List.401; - let List.606 : List U8 = CallByName List.72 List.400 List.607 List.608; - ret List.606; + let List.599 : U64 = StructAtIndex 1 List.401; + let List.600 : U64 = StructAtIndex 0 List.401; + let List.598 : List U8 = CallByName List.72 List.400 List.599 List.600; + ret List.598; procedure List.6 (#Attr.2): - let List.638 : U64 = lowlevel ListLen #Attr.2; - ret List.638; + let List.626 : U64 = lowlevel ListLen #Attr.2; + ret List.626; procedure List.66 (#Attr.2, #Attr.3): - let List.591 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.591; + let List.587 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.587; procedure List.70 (#Attr.2, #Attr.3): - let List.582 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; - ret List.582; + let List.578 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.578; procedure List.71 (#Attr.2, #Attr.3): - let List.580 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; - ret List.580; + let List.576 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.576; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): let List.559 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; ret List.559; procedure List.8 (#Attr.2, #Attr.3): - let List.577 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; - ret List.577; + let List.573 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3; + ret List.573; procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4): - joinpoint List.626 List.471 List.472 List.473 List.474 List.475: - let List.628 : Int1 = CallByName Num.22 List.474 List.475; - if List.628 then - let List.637 : U8 = CallByName List.66 List.471 List.474; - let List.629 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.472 List.637; - let List.634 : U8 = 1i64; - let List.635 : U8 = GetTagId List.629; - let List.636 : Int1 = lowlevel Eq List.634 List.635; - if List.636 then - let List.476 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.629; - let List.632 : U64 = 1i64; - let List.631 : U64 = CallByName Num.51 List.474 List.632; - jump List.626 List.471 List.476 List.473 List.631 List.475; + joinpoint List.614 List.471 List.472 List.473 List.474 List.475: + let List.616 : Int1 = CallByName Num.22 List.474 List.475; + if List.616 then + let List.625 : U8 = CallByName List.66 List.471 List.474; + let List.617 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.472 List.625; + let List.622 : U8 = 1i64; + let List.623 : U8 = GetTagId List.617; + let List.624 : Int1 = lowlevel Eq List.622 List.623; + if List.624 then + let List.476 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.617; + let List.620 : U64 = 1i64; + let List.619 : U64 = CallByName Num.51 List.474 List.620; + jump List.614 List.471 List.476 List.473 List.619 List.475; else dec List.471; - let List.477 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.629; - let List.633 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.477; - ret List.633; + let List.477 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.617; + let List.621 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.477; + ret List.621; else dec List.471; - let List.627 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.472; - ret List.627; + let List.615 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.472; + ret List.615; in - jump List.626 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; + jump List.614 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; procedure List.99 (List.468, List.469, List.470): - let List.624 : U64 = 0i64; - let List.625 : U64 = CallByName List.6 List.468; - let List.623 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.468 List.469 List.470 List.624 List.625; - ret List.623; + let List.612 : U64 = 0i64; + let List.613 : U64 = CallByName List.6 List.468; + let List.611 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.468 List.469 List.470 List.612 List.613; + ret List.611; procedure Num.19 (#Attr.2, #Attr.3): let Num.294 : U8 = lowlevel NumAdd #Attr.2 #Attr.3; diff --git a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt index 9bfa27aaeb..91c3e884f1 100644 --- a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt +++ b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt @@ -1,7 +1,3 @@ -procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.24; - procedure Bool.2 (): let Bool.23 : Int1 = true; ret Bool.23; @@ -46,15 +42,15 @@ procedure List.18 (List.154, List.155, List.156): ret List.591; procedure List.26 (List.181, List.182, List.183): - let List.633 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; - let List.636 : U8 = 1i64; - let List.637 : U8 = GetTagId List.633; - let List.638 : Int1 = lowlevel Eq List.636 List.637; - if List.638 then - let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.633; + let List.629 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183; + let List.632 : U8 = 1i64; + let List.633 : U8 = GetTagId List.629; + let List.634 : Int1 = lowlevel Eq List.632 List.633; + if List.634 then + let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.629; ret List.184; else - let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.633; + let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.629; ret List.185; procedure List.4 (List.119, List.120): @@ -64,37 +60,29 @@ procedure List.4 (List.119, List.120): ret List.576; procedure List.49 (List.400, List.401): - let List.625 : U64 = StructAtIndex 0 List.401; - let List.626 : U64 = 0i64; - let List.623 : Int1 = CallByName Bool.11 List.625 List.626; - if List.623 then - dec List.400; - let List.624 : List U8 = Array []; - ret List.624; - else - let List.620 : U64 = StructAtIndex 1 List.401; - let List.621 : U64 = StructAtIndex 0 List.401; - let List.619 : List U8 = CallByName List.72 List.400 List.620 List.621; - ret List.619; + let List.620 : U64 = StructAtIndex 1 List.401; + let List.621 : U64 = StructAtIndex 0 List.401; + let List.619 : List U8 = CallByName List.72 List.400 List.620 List.621; + ret List.619; procedure List.52 (List.415, List.416): let List.417 : U64 = CallByName List.6 List.415; - joinpoint List.631 List.418: - let List.629 : U64 = 0i64; - let List.628 : {U64, U64} = Struct {List.418, List.629}; + joinpoint List.627 List.418: + let List.625 : U64 = 0i64; + let List.624 : {U64, U64} = Struct {List.418, List.625}; inc List.415; - let List.419 : List U8 = CallByName List.49 List.415 List.628; - let List.627 : U64 = CallByName Num.75 List.417 List.418; - let List.618 : {U64, U64} = Struct {List.627, List.418}; + let List.419 : List U8 = CallByName List.49 List.415 List.624; + let List.623 : U64 = CallByName Num.75 List.417 List.418; + let List.618 : {U64, U64} = Struct {List.623, List.418}; let List.420 : List U8 = CallByName List.49 List.415 List.618; let List.617 : {List U8, List U8} = Struct {List.419, List.420}; ret List.617; in - let List.632 : Int1 = CallByName Num.24 List.417 List.416; - if List.632 then - jump List.631 List.416; + let List.628 : Int1 = CallByName Num.24 List.417 List.416; + if List.628 then + jump List.627 List.416; else - jump List.631 List.417; + jump List.627 List.417; procedure List.6 (#Attr.2): let List.603 : U64 = lowlevel ListLen #Attr.2; @@ -133,30 +121,30 @@ procedure List.8 (#Attr.2, #Attr.3): ret List.614; procedure List.80 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17): - joinpoint List.642 List.471 List.472 List.473 List.474 List.475: - let List.644 : Int1 = CallByName Num.22 List.474 List.475; - if List.644 then - let List.653 : U8 = CallByName List.66 List.471 List.474; - let List.645 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.653; - let List.650 : U8 = 1i64; - let List.651 : U8 = GetTagId List.645; - let List.652 : Int1 = lowlevel Eq List.650 List.651; - if List.652 then - let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.645; - let List.648 : U64 = 1i64; - let List.647 : U64 = CallByName Num.51 List.474 List.648; - jump List.642 List.471 List.476 List.473 List.647 List.475; + joinpoint List.638 List.471 List.472 List.473 List.474 List.475: + let List.640 : Int1 = CallByName Num.22 List.474 List.475; + if List.640 then + let List.649 : U8 = CallByName List.66 List.471 List.474; + let List.641 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.649; + let List.646 : U8 = 1i64; + let List.647 : U8 = GetTagId List.641; + let List.648 : Int1 = lowlevel Eq List.646 List.647; + if List.648 then + let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.641; + let List.644 : U64 = 1i64; + let List.643 : U64 = CallByName Num.51 List.474 List.644; + jump List.638 List.471 List.476 List.473 List.643 List.475; else dec List.471; - let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.645; - let List.649 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; - ret List.649; + let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.641; + let List.645 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477; + ret List.645; else dec List.471; - let List.643 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; - ret List.643; + let List.639 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472; + ret List.639; in - jump List.642 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17; + jump List.638 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17; procedure List.88 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4): joinpoint List.582 List.157 List.158 List.159 List.160 List.161: @@ -190,10 +178,10 @@ procedure List.88 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen jump List.594 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12; procedure List.99 (List.468, List.469, List.470): - let List.640 : U64 = 0i64; - let List.641 : U64 = CallByName List.6 List.468; - let List.639 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.640 List.641; - ret List.639; + let List.636 : U64 = 0i64; + let List.637 : U64 = CallByName List.6 List.468; + let List.635 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.636 List.637; + ret List.635; procedure Num.127 (#Attr.2): let Num.298 : U8 = lowlevel NumIntCast #Attr.2; diff --git a/crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt b/crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt index 7edfa98314..2eff3f8800 100644 --- a/crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt +++ b/crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt @@ -1,89 +1,81 @@ procedure Bool.11 (#Attr.2, #Attr.3): - let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.24; + let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.23; procedure List.26 (List.181, List.182, List.183): - let List.568 : [C U64, C U64] = CallByName List.99 List.181 List.182 List.183; - let List.571 : U8 = 1i64; - let List.572 : U8 = GetTagId List.568; - let List.573 : Int1 = lowlevel Eq List.571 List.572; - if List.573 then - let List.184 : U64 = UnionAtIndex (Id 1) (Index 0) List.568; + let List.564 : [C U64, C U64] = CallByName List.99 List.181 List.182 List.183; + let List.567 : U8 = 1i64; + let List.568 : U8 = GetTagId List.564; + let List.569 : Int1 = lowlevel Eq List.567 List.568; + if List.569 then + let List.184 : U64 = UnionAtIndex (Id 1) (Index 0) List.564; ret List.184; else - let List.185 : U64 = UnionAtIndex (Id 0) (Index 0) List.568; + let List.185 : U64 = UnionAtIndex (Id 0) (Index 0) List.564; ret List.185; procedure List.38 (List.324, List.325): - let List.567 : U64 = CallByName List.6 List.324; - let List.326 : U64 = CallByName Num.77 List.567 List.325; + let List.563 : U64 = CallByName List.6 List.324; + let List.326 : U64 = CallByName Num.77 List.563 List.325; let List.553 : List U8 = CallByName List.43 List.324 List.326; ret List.553; procedure List.43 (List.322, List.323): - let List.565 : U64 = CallByName List.6 List.322; - let List.564 : U64 = CallByName Num.77 List.565 List.323; - let List.555 : {U64, U64} = Struct {List.323, List.564}; + let List.561 : U64 = CallByName List.6 List.322; + let List.560 : U64 = CallByName Num.77 List.561 List.323; + let List.555 : {U64, U64} = Struct {List.323, List.560}; let List.554 : List U8 = CallByName List.49 List.322 List.555; ret List.554; procedure List.49 (List.400, List.401): - let List.562 : U64 = StructAtIndex 0 List.401; - let List.563 : U64 = 0i64; - let List.560 : Int1 = CallByName Bool.11 List.562 List.563; - if List.560 then - dec List.400; - let List.561 : List U8 = Array []; - ret List.561; - else - let List.557 : U64 = StructAtIndex 1 List.401; - let List.558 : U64 = StructAtIndex 0 List.401; - let List.556 : List U8 = CallByName List.72 List.400 List.557 List.558; - ret List.556; + let List.557 : U64 = StructAtIndex 1 List.401; + let List.558 : U64 = StructAtIndex 0 List.401; + let List.556 : List U8 = CallByName List.72 List.400 List.557 List.558; + ret List.556; procedure List.6 (#Attr.2): - let List.566 : U64 = lowlevel ListLen #Attr.2; - ret List.566; + let List.562 : U64 = lowlevel ListLen #Attr.2; + ret List.562; procedure List.66 (#Attr.2, #Attr.3): - let List.589 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - ret List.589; + let List.585 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.585; procedure List.72 (#Attr.2, #Attr.3, #Attr.4): let List.559 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4; ret List.559; procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4): - joinpoint List.577 List.471 List.472 List.473 List.474 List.475: - let List.579 : Int1 = CallByName Num.22 List.474 List.475; - if List.579 then - let List.588 : U8 = CallByName List.66 List.471 List.474; - let List.580 : [C U64, C U64] = CallByName Test.3 List.472 List.588; - let List.585 : U8 = 1i64; - let List.586 : U8 = GetTagId List.580; - let List.587 : Int1 = lowlevel Eq List.585 List.586; - if List.587 then - let List.476 : U64 = UnionAtIndex (Id 1) (Index 0) List.580; - let List.583 : U64 = 1i64; - let List.582 : U64 = CallByName Num.51 List.474 List.583; - jump List.577 List.471 List.476 List.473 List.582 List.475; + joinpoint List.573 List.471 List.472 List.473 List.474 List.475: + let List.575 : Int1 = CallByName Num.22 List.474 List.475; + if List.575 then + let List.584 : U8 = CallByName List.66 List.471 List.474; + let List.576 : [C U64, C U64] = CallByName Test.3 List.472 List.584; + let List.581 : U8 = 1i64; + let List.582 : U8 = GetTagId List.576; + let List.583 : Int1 = lowlevel Eq List.581 List.582; + if List.583 then + let List.476 : U64 = UnionAtIndex (Id 1) (Index 0) List.576; + let List.579 : U64 = 1i64; + let List.578 : U64 = CallByName Num.51 List.474 List.579; + jump List.573 List.471 List.476 List.473 List.578 List.475; else dec List.471; - let List.477 : U64 = UnionAtIndex (Id 0) (Index 0) List.580; - let List.584 : [C U64, C U64] = TagId(0) List.477; - ret List.584; + let List.477 : U64 = UnionAtIndex (Id 0) (Index 0) List.576; + let List.580 : [C U64, C U64] = TagId(0) List.477; + ret List.580; else dec List.471; - let List.578 : [C U64, C U64] = TagId(1) List.472; - ret List.578; + let List.574 : [C U64, C U64] = TagId(1) List.472; + ret List.574; in - jump List.577 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; + jump List.573 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4; procedure List.99 (List.468, List.469, List.470): - let List.575 : U64 = 0i64; - let List.576 : U64 = CallByName List.6 List.468; - let List.574 : [C U64, C U64] = CallByName List.80 List.468 List.469 List.470 List.575 List.576; - ret List.574; + let List.571 : U64 = 0i64; + let List.572 : U64 = CallByName List.6 List.468; + let List.570 : [C U64, C U64] = CallByName List.80 List.468 List.469 List.470 List.571 List.572; + ret List.570; procedure Num.22 (#Attr.2, #Attr.3): let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; From af5b209c9f62d620f09436f7571306fa98fee025 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Mon, 20 Nov 2023 21:33:47 -0800 Subject: [PATCH 12/18] misc cleanup suggestions --- crates/compiler/mono/src/ir/pattern.rs | 26 +++++++++++++++------ crates/compiler/mono/src/layout/semantic.rs | 2 +- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/crates/compiler/mono/src/ir/pattern.rs b/crates/compiler/mono/src/ir/pattern.rs index 838aa46adb..b8f9fdb408 100644 --- a/crates/compiler/mono/src/ir/pattern.rs +++ b/crates/compiler/mono/src/ir/pattern.rs @@ -1544,10 +1544,27 @@ fn store_list_pattern<'a>( } } + stmt = store_list_rest(env, list_sym, list_arity, list_layout, opt_rest, stmt); + + if is_productive { + StorePattern::Productive(stmt) + } else { + StorePattern::NotProductive(stmt) + } +} + +fn store_list_rest<'a>( + env: &mut Env<'a, '_>, + list_sym: Symbol, + list_arity: ListArity, + list_layout: InLayout<'a>, + opt_rest: &Option<(usize, Option)>, + mut stmt: Stmt<'a>, +) -> Stmt<'a> { if let Some((index, Some(rest_sym))) = opt_rest { let usize_layout = Layout::usize(env.target_info); - let total_dropped = elements.len(); + let total_dropped = list_arity.min_len(); let total_dropped_sym = env.unique_symbol(); let total_dropped_expr = Expr::Literal(Literal::Int((total_dropped as u128).to_ne_bytes())); @@ -1591,12 +1608,7 @@ fn store_list_pattern<'a>( stmt = Stmt::Let(sym, expr, lay, env.arena.alloc(stmt)); } } - - if is_productive { - StorePattern::Productive(stmt) - } else { - StorePattern::NotProductive(stmt) - } + stmt } #[allow(clippy::too_many_arguments)] diff --git a/crates/compiler/mono/src/layout/semantic.rs b/crates/compiler/mono/src/layout/semantic.rs index 38033657a3..293e719e59 100644 --- a/crates/compiler/mono/src/layout/semantic.rs +++ b/crates/compiler/mono/src/layout/semantic.rs @@ -47,7 +47,7 @@ impl<'a> SemanticRepr<'a> { pub(super) const NONE: Self = Self(Inner::None); pub(super) const EMPTY_RECORD: Self = Self::record(&[]); - pub(crate) const fn record(fields: &'a [&'a str]) -> Self { + pub(super) const fn record(fields: &'a [&'a str]) -> Self { Self(Inner::Record(SemaRecord { fields })) } From d21ea2ea832ab64ff454736054c9c541c5099816 Mon Sep 17 00:00:00 2001 From: jecaro Date: Tue, 21 Nov 2023 10:52:35 +0100 Subject: [PATCH 13/18] Fix zig_host_app on NixOS That's a problem with the dynamic loader: https://discourse.nixos.org/t/no-such-file-of-directory-when-trying-to-execute-binary-file/6150 When linking `libapp.so` with `host.zig`, zig puts in the binary the standard path for the dynamic loader on linux: `/lib64/ld-linux-x86-64.so.2` However in NixOS, that file is somewhere else in the nix store (see: https://nixos.wiki/wiki/Packaging/Binaries#The_Dynamic_Loader). Removing the `-target` switch makes zig uses the host target for linking and puts the right path to the dynamic loader in the resulting binary. As we want to execute that binary file in this test, it makes sense to use the default target anyway. Note that this is relevant for the creation of the binary only. For the creation of the object file, it doesn't really matter. But I removed the `-target` switch as well there for consistency. Fix #4180 --- crates/linker/src/elf.rs | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/crates/linker/src/elf.rs b/crates/linker/src/elf.rs index 7ddf0dafd4..37458bdc4d 100644 --- a/crates/linker/src/elf.rs +++ b/crates/linker/src/elf.rs @@ -1832,14 +1832,7 @@ mod tests { // we need to compile the app first let output = std::process::Command::new(&zig) .current_dir(dir) - .args([ - "build-obj", - "app.zig", - "-fPIC", - "-target", - "x86_64-linux-gnu", - "-OReleaseFast", - ]) + .args(["build-obj", "app.zig", "-fPIC", "-OReleaseFast"]) .output() .unwrap(); @@ -1878,8 +1871,6 @@ mod tests { "host.zig", "-fPIE", "-lc", - "-target", - "x86_64-linux-gnu", "-OReleaseFast", ]) .output() From 4366d1f058ee2c393b5a82365a7387a366a5738f Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 21 Nov 2023 14:27:23 +0100 Subject: [PATCH 14/18] update basic cli arm64 test --- .github/workflows/basic_cli_test_arm64.yml | 10 +++++++--- .github/workflows/basic_webserver_build_release.yml | 2 +- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/.github/workflows/basic_cli_test_arm64.yml b/.github/workflows/basic_cli_test_arm64.yml index fc4ef3d476..f5300283d4 100644 --- a/.github/workflows/basic_cli_test_arm64.yml +++ b/.github/workflows/basic_cli_test_arm64.yml @@ -1,5 +1,6 @@ on: workflow_dispatch: + pull_request: # this cancels workflows currently in progress if you start a new one concurrency: @@ -45,10 +46,13 @@ jobs: - name: Remove roc_nightly folder to keep things simple (we'll download it again later) run: rm -rf roc_nightly - - name: Get the examples of the latest basic-cli release - run: ./ci/get_latest_release_examples.sh + - name: Get the repo of the latest basic-cli release + run: | + mkdir basic-cli + cd basic-cli + ./ci/get_latest_release_git_files.sh - name: Run all tests with latest roc nightly and latest basic-cli release run: | sed -i 's/x86_64/arm64/g' ./ci/test_latest_release.sh - ROC=./roc_nightly/roc EXAMPLES_DIR=./latest-release-examples/ ./ci/test_latest_release.sh + ROC=./roc_nightly/roc EXAMPLES_DIR=./basic-cli/examples/ ./ci/test_latest_release.sh diff --git a/.github/workflows/basic_webserver_build_release.yml b/.github/workflows/basic_webserver_build_release.yml index f1cad66170..aac03696b0 100644 --- a/.github/workflows/basic_webserver_build_release.yml +++ b/.github/workflows/basic_webserver_build_release.yml @@ -37,7 +37,7 @@ jobs: - name: Download the previously uploaded roc_nightly archives uses: actions/download-artifact@v3 - - name: build basic-webserver with surgical linker and also with legacy linker + - name: build basic-webserver with legacy linker env: CARGO_BUILD_TARGET: x86_64-unknown-linux-musl run: ./ci/build_basic_webserver.sh linux_x86_64 "--linker legacy" From 819f02f873ebe45bda4b7422fd22ee971d20246e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 21 Nov 2023 14:47:04 +0100 Subject: [PATCH 15/18] fix get latest tag repo Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_test_arm64.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/basic_cli_test_arm64.yml b/.github/workflows/basic_cli_test_arm64.yml index f5300283d4..388ba8701e 100644 --- a/.github/workflows/basic_cli_test_arm64.yml +++ b/.github/workflows/basic_cli_test_arm64.yml @@ -48,9 +48,11 @@ jobs: - name: Get the repo of the latest basic-cli release run: | - mkdir basic-cli + git clone --depth 1 https://github.com/roc-lang/basic-cli cd basic-cli - ./ci/get_latest_release_git_files.sh + git fetch --tags + latestTag=$(git describe --tags $(git rev-list --tags --max-count=1)) + git checkout $latestTag - name: Run all tests with latest roc nightly and latest basic-cli release run: | From 3db18bbd4cfeabf10bb62737378886545f74b52e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 21 Nov 2023 15:32:09 +0100 Subject: [PATCH 16/18] remove PR trigger Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_test_arm64.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/basic_cli_test_arm64.yml b/.github/workflows/basic_cli_test_arm64.yml index 388ba8701e..4ea02715c3 100644 --- a/.github/workflows/basic_cli_test_arm64.yml +++ b/.github/workflows/basic_cli_test_arm64.yml @@ -1,6 +1,5 @@ on: workflow_dispatch: - pull_request: # this cancels workflows currently in progress if you start a new one concurrency: From 38ad8f106143f4c9236f13d0e46fc19798fd0cd5 Mon Sep 17 00:00:00 2001 From: Ikko Eltociear Ashimine Date: Wed, 22 Nov 2023 01:02:02 +0900 Subject: [PATCH 17/18] Fix typo in optimize.sh occurances -> occurrences Signed-off-by: Ikko Eltociear Ashimine --- www/optimize.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/www/optimize.sh b/www/optimize.sh index 1fae5b8981..e86f61bf7a 100755 --- a/www/optimize.sh +++ b/www/optimize.sh @@ -49,5 +49,5 @@ rm dist/site.css # Find the new filename css_with_hash=$(basename dist/site-*.css) -# Replace all occurances in the html +# Replace all occurrences in the html sed -i "s:/wip/site.css:/wip/${css_with_hash}:g" dist/*.html From f3220c7d457a0d96af4235ad339513d65b30d1bb Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 21 Nov 2023 19:10:45 +0100 Subject: [PATCH 18/18] auto delete old nix shells Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/nix_macos_apple_silicon.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/nix_macos_apple_silicon.yml b/.github/workflows/nix_macos_apple_silicon.yml index 8958dbe0cf..f885c4ca7b 100644 --- a/.github/workflows/nix_macos_apple_silicon.yml +++ b/.github/workflows/nix_macos_apple_silicon.yml @@ -18,6 +18,10 @@ jobs: steps: - uses: actions/checkout@v3 + # These started to accumulate quickly since #5990, not sure why + - name: Clean up old nix shells + run: rm -rf /private/tmp/nix-shell.* + - run: zig version - name: check formatting with rustfmt