mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-22 00:09:33 +03:00
remove now-unused mono files
This commit is contained in:
parent
378fe1d5d1
commit
9dbce40a55
@ -1,6 +1,6 @@
|
||||
use crate::expr::{DestructType, Env, Expr, Pattern};
|
||||
use crate::exhaustive::{Ctor, RenderAs, TagId, Union};
|
||||
use crate::ir::{DestructType, Env, Expr, JoinPointId, Literal, Pattern, Stmt};
|
||||
use crate::layout::{Builtin, Layout};
|
||||
use crate::pattern::{Ctor, RenderAs, TagId, Union};
|
||||
use bumpalo::Bump;
|
||||
use roc_collections::all::{MutMap, MutSet};
|
||||
use roc_module::ident::TagName;
|
||||
@ -31,8 +31,12 @@ pub fn compile<'a>(raw_branches: Vec<(Guard<'a>, Pattern<'a>, u64)>) -> Decision
|
||||
pub enum Guard<'a> {
|
||||
NoGuard,
|
||||
Guard {
|
||||
stores: &'a [(Symbol, Layout<'a>, Expr<'a>)],
|
||||
expr: Expr<'a>,
|
||||
/// Symbol that stores a boolean
|
||||
/// when true this branch is picked, otherwise skipped
|
||||
symbol: Symbol,
|
||||
/// after assigning to symbol, the stmt jumps to this label
|
||||
id: JoinPointId,
|
||||
stmt: Stmt<'a>,
|
||||
},
|
||||
}
|
||||
|
||||
@ -57,7 +61,7 @@ pub enum Test<'a> {
|
||||
IsCtor {
|
||||
tag_id: u8,
|
||||
tag_name: TagName,
|
||||
union: crate::pattern::Union,
|
||||
union: crate::exhaustive::Union,
|
||||
arguments: Vec<(Pattern<'a>, Layout<'a>)>,
|
||||
},
|
||||
IsInt(i64),
|
||||
@ -72,8 +76,12 @@ pub enum Test<'a> {
|
||||
// A pattern that always succeeds (like `_`) can still have a guard
|
||||
Guarded {
|
||||
opt_test: Option<Box<Test<'a>>>,
|
||||
stores: &'a [(Symbol, Layout<'a>, Expr<'a>)],
|
||||
expr: Expr<'a>,
|
||||
/// Symbol that stores a boolean
|
||||
/// when true this branch is picked, otherwise skipped
|
||||
symbol: Symbol,
|
||||
/// after assigning to symbol, the stmt jumps to this label
|
||||
id: JoinPointId,
|
||||
stmt: Stmt<'a>,
|
||||
},
|
||||
}
|
||||
use std::hash::{Hash, Hasher};
|
||||
@ -353,11 +361,12 @@ fn test_at_path<'a>(selected_path: &Path, branch: Branch<'a>, all_tests: &mut Ve
|
||||
None => {}
|
||||
Some((_, guard, pattern)) => {
|
||||
let guarded = |test| {
|
||||
if let Guard::Guard { stores, expr } = guard {
|
||||
if let Guard::Guard { symbol, id, stmt } = guard {
|
||||
Guarded {
|
||||
opt_test: Some(Box::new(test)),
|
||||
stores,
|
||||
expr: expr.clone(),
|
||||
stmt: stmt.clone(),
|
||||
symbol: *symbol,
|
||||
id: *id,
|
||||
}
|
||||
} else {
|
||||
test
|
||||
@ -367,11 +376,12 @@ fn test_at_path<'a>(selected_path: &Path, branch: Branch<'a>, all_tests: &mut Ve
|
||||
match pattern {
|
||||
// TODO use guard!
|
||||
Identifier(_) | Underscore | Shadowed(_, _) | UnsupportedPattern(_) => {
|
||||
if let Guard::Guard { stores, expr } = guard {
|
||||
if let Guard::Guard { symbol, id, stmt } = guard {
|
||||
all_tests.push(Guarded {
|
||||
opt_test: None,
|
||||
stores,
|
||||
expr: expr.clone(),
|
||||
stmt: stmt.clone(),
|
||||
symbol: *symbol,
|
||||
id: *id,
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -575,6 +585,8 @@ fn to_relevant_branch_help<'a>(
|
||||
start.push((Path::Unbox(Box::new(path.clone())), guard, arg.0));
|
||||
start.extend(end);
|
||||
}
|
||||
} else if union.alternatives.len() == 1 {
|
||||
todo!("this should need a special index, right?")
|
||||
} else {
|
||||
let sub_positions =
|
||||
arguments
|
||||
@ -863,31 +875,29 @@ enum Decider<'a, T> {
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
enum Choice<'a> {
|
||||
Inline(Stores<'a>, Expr<'a>),
|
||||
Inline(Stmt<'a>),
|
||||
Jump(Label),
|
||||
}
|
||||
|
||||
type Stores<'a> = &'a [(Symbol, Layout<'a>, Expr<'a>)];
|
||||
type StoresVec<'a> = bumpalo::collections::Vec<'a, (Symbol, Layout<'a>, Expr<'a>)>;
|
||||
|
||||
pub fn optimize_when<'a>(
|
||||
env: &mut Env<'a, '_>,
|
||||
cond_symbol: Symbol,
|
||||
cond_layout: Layout<'a>,
|
||||
ret_layout: Layout<'a>,
|
||||
opt_branches: Vec<(Pattern<'a>, Guard<'a>, Stores<'a>, Expr<'a>)>,
|
||||
) -> Expr<'a> {
|
||||
opt_branches: bumpalo::collections::Vec<'a, (Pattern<'a>, Guard<'a>, Stmt<'a>)>,
|
||||
) -> Stmt<'a> {
|
||||
let (patterns, _indexed_branches) = opt_branches
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(index, (pattern, guard, stores, branch))| {
|
||||
(
|
||||
(guard, pattern, index as u64),
|
||||
(index as u64, stores, branch),
|
||||
)
|
||||
.map(|(index, (pattern, guard, branch))| {
|
||||
((guard, pattern, index as u64), (index as u64, branch))
|
||||
})
|
||||
.unzip();
|
||||
|
||||
let indexed_branches: Vec<(u64, Stores<'a>, Expr<'a>)> = _indexed_branches;
|
||||
let indexed_branches: Vec<(u64, Stmt<'a>)> = _indexed_branches;
|
||||
|
||||
let decision_tree = compile(patterns);
|
||||
let decider = tree_to_decider(decision_tree);
|
||||
@ -896,9 +906,8 @@ pub fn optimize_when<'a>(
|
||||
let mut choices = MutMap::default();
|
||||
let mut jumps = Vec::new();
|
||||
|
||||
for (index, stores, branch) in indexed_branches.into_iter() {
|
||||
let ((branch_index, choice), opt_jump) =
|
||||
create_choices(&target_counts, index, stores, branch);
|
||||
for (index, branch) in indexed_branches.into_iter() {
|
||||
let ((branch_index, choice), opt_jump) = create_choices(&target_counts, index, branch);
|
||||
|
||||
if let Some(jump) = opt_jump {
|
||||
jumps.push(jump);
|
||||
@ -909,7 +918,7 @@ pub fn optimize_when<'a>(
|
||||
|
||||
let choice_decider = insert_choices(&choices, decider);
|
||||
|
||||
let (stores, expr) = decide_to_branching(
|
||||
let expr = decide_to_branching(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout,
|
||||
@ -921,7 +930,7 @@ pub fn optimize_when<'a>(
|
||||
// increase the jump counter by the number of jumps in this branching structure
|
||||
*env.jump_counter += jumps.len() as u64;
|
||||
|
||||
Expr::Store(stores, env.arena.alloc(expr))
|
||||
expr
|
||||
}
|
||||
|
||||
fn path_to_expr<'a>(
|
||||
@ -929,47 +938,62 @@ fn path_to_expr<'a>(
|
||||
symbol: Symbol,
|
||||
path: &Path,
|
||||
layout: &Layout<'a>,
|
||||
) -> Expr<'a> {
|
||||
path_to_expr_help(env, symbol, path, layout.clone()).0
|
||||
) -> (StoresVec<'a>, Symbol) {
|
||||
let (symbol, stores, _) = path_to_expr_help2(env, symbol, path, layout.clone());
|
||||
|
||||
(stores, symbol)
|
||||
}
|
||||
|
||||
fn path_to_expr_help<'a>(
|
||||
fn path_to_expr_help2<'a>(
|
||||
env: &mut Env<'a, '_>,
|
||||
symbol: Symbol,
|
||||
path: &Path,
|
||||
layout: Layout<'a>,
|
||||
) -> (Expr<'a>, Layout<'a>) {
|
||||
match path {
|
||||
Path::Unbox(unboxed) => path_to_expr_help(env, symbol, unboxed, layout),
|
||||
Path::Empty => (Expr::Load(symbol), layout),
|
||||
mut symbol: Symbol,
|
||||
mut path: &Path,
|
||||
mut layout: Layout<'a>,
|
||||
) -> (Symbol, StoresVec<'a>, Layout<'a>) {
|
||||
let mut stores = bumpalo::collections::Vec::new_in(env.arena);
|
||||
|
||||
Path::Index {
|
||||
index,
|
||||
tag_id,
|
||||
path: nested,
|
||||
} => {
|
||||
let (outer_expr, outer_layout) = path_to_expr_help(env, symbol, nested, layout);
|
||||
loop {
|
||||
match path {
|
||||
Path::Unbox(unboxed) => {
|
||||
path = unboxed;
|
||||
}
|
||||
Path::Empty => break,
|
||||
|
||||
let (is_unwrapped, field_layouts) = match outer_layout {
|
||||
Layout::Union(layouts) => (layouts.is_empty(), layouts[*tag_id as usize].to_vec()),
|
||||
Layout::Struct(layouts) => (true, layouts.to_vec()),
|
||||
other => (true, vec![other]),
|
||||
};
|
||||
Path::Index {
|
||||
index,
|
||||
tag_id,
|
||||
path: nested,
|
||||
} => {
|
||||
let (is_unwrapped, field_layouts) = match layout.clone() {
|
||||
Layout::Union(layouts) => {
|
||||
(layouts.is_empty(), layouts[*tag_id as usize].to_vec())
|
||||
}
|
||||
Layout::Struct(layouts) => (true, layouts.to_vec()),
|
||||
other => (true, vec![other]),
|
||||
};
|
||||
|
||||
debug_assert!(*index < field_layouts.len() as u64);
|
||||
debug_assert!(*index < field_layouts.len() as u64);
|
||||
|
||||
let inner_layout = field_layouts[*index as usize].clone();
|
||||
let inner_layout = field_layouts[*index as usize].clone();
|
||||
|
||||
let inner_expr = Expr::AccessAtIndex {
|
||||
index: *index,
|
||||
field_layouts: env.arena.alloc(field_layouts),
|
||||
expr: env.arena.alloc(outer_expr),
|
||||
is_unwrapped,
|
||||
};
|
||||
let inner_expr = Expr::AccessAtIndex {
|
||||
index: *index,
|
||||
field_layouts: env.arena.alloc(field_layouts),
|
||||
//structure: env.arena.alloc(outer_expr),
|
||||
structure: symbol,
|
||||
is_unwrapped,
|
||||
};
|
||||
|
||||
(inner_expr, inner_layout)
|
||||
symbol = env.unique_symbol();
|
||||
stores.push((symbol, inner_layout.clone(), inner_expr));
|
||||
|
||||
layout = inner_layout;
|
||||
path = nested;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(symbol, stores, layout)
|
||||
}
|
||||
|
||||
fn test_to_equality<'a>(
|
||||
@ -978,8 +1002,7 @@ fn test_to_equality<'a>(
|
||||
cond_layout: &Layout<'a>,
|
||||
path: &Path,
|
||||
test: Test<'a>,
|
||||
tests: &mut Vec<(Expr<'a>, Expr<'a>, Layout<'a>)>,
|
||||
) {
|
||||
) -> (StoresVec<'a>, Symbol, Symbol, Layout<'a>) {
|
||||
match test {
|
||||
Test::IsCtor {
|
||||
tag_id,
|
||||
@ -991,7 +1014,7 @@ fn test_to_equality<'a>(
|
||||
// (e.g. record pattern guard matches)
|
||||
debug_assert!(union.alternatives.len() > 1);
|
||||
|
||||
let lhs = Expr::Int(tag_id as i64);
|
||||
let lhs = Expr::Literal(Literal::Int(tag_id as i64));
|
||||
|
||||
let mut field_layouts =
|
||||
bumpalo::collections::Vec::with_capacity_in(arguments.len(), env.arena);
|
||||
@ -1006,65 +1029,101 @@ fn test_to_equality<'a>(
|
||||
let rhs = Expr::AccessAtIndex {
|
||||
index: 0,
|
||||
field_layouts: field_layouts.into_bump_slice(),
|
||||
expr: env.arena.alloc(Expr::Load(cond_symbol)),
|
||||
structure: cond_symbol,
|
||||
is_unwrapped: union.alternatives.len() == 1,
|
||||
};
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Int64)));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let rhs_symbol = env.unique_symbol();
|
||||
|
||||
let mut stores = bumpalo::collections::Vec::with_capacity_in(2, env.arena);
|
||||
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Int64), lhs));
|
||||
stores.push((rhs_symbol, Layout::Builtin(Builtin::Int64), rhs));
|
||||
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Int64),
|
||||
)
|
||||
}
|
||||
Test::IsInt(test_int) => {
|
||||
let lhs = Expr::Int(test_int);
|
||||
let rhs = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
let lhs = Expr::Literal(Literal::Int(test_int));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let (mut stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Int64), lhs));
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Int64)));
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Int64),
|
||||
)
|
||||
}
|
||||
|
||||
Test::IsFloat(test_int) => {
|
||||
// TODO maybe we can actually use i64 comparison here?
|
||||
let test_float = f64::from_bits(test_int as u64);
|
||||
let lhs = Expr::Float(test_float);
|
||||
let rhs = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
let lhs = Expr::Literal(Literal::Float(test_float));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let (mut stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Float64), lhs));
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Float64)));
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Float64),
|
||||
)
|
||||
}
|
||||
|
||||
Test::IsByte {
|
||||
tag_id: test_byte, ..
|
||||
} => {
|
||||
let lhs = Expr::Byte(test_byte);
|
||||
let rhs = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
let lhs = Expr::Literal(Literal::Byte(test_byte));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let (mut stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Int8), lhs));
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Int8)));
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Int8),
|
||||
)
|
||||
}
|
||||
|
||||
Test::IsBit(test_bit) => {
|
||||
let lhs = Expr::Bool(test_bit);
|
||||
let rhs = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
let lhs = Expr::Literal(Literal::Bool(test_bit));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let (mut stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Int1), lhs));
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Int1)));
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Int1),
|
||||
)
|
||||
}
|
||||
|
||||
Test::IsStr(test_str) => {
|
||||
let lhs = Expr::Str(env.arena.alloc(test_str));
|
||||
let rhs = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
let lhs = Expr::Literal(Literal::Str(env.arena.alloc(test_str)));
|
||||
let lhs_symbol = env.unique_symbol();
|
||||
let (mut stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Str)));
|
||||
stores.push((lhs_symbol, Layout::Builtin(Builtin::Str), lhs));
|
||||
|
||||
(
|
||||
stores,
|
||||
lhs_symbol,
|
||||
rhs_symbol,
|
||||
Layout::Builtin(Builtin::Str),
|
||||
)
|
||||
}
|
||||
|
||||
Test::Guarded {
|
||||
opt_test,
|
||||
stores,
|
||||
expr,
|
||||
} => {
|
||||
if let Some(nested) = opt_test {
|
||||
test_to_equality(env, cond_symbol, cond_layout, path, *nested, tests);
|
||||
}
|
||||
|
||||
let lhs = Expr::Bool(true);
|
||||
let rhs = Expr::Store(stores, env.arena.alloc(expr));
|
||||
|
||||
tests.push((lhs, rhs, Layout::Builtin(Builtin::Int1)));
|
||||
}
|
||||
Test::Guarded { .. } => unreachable!("should be handled elsewhere"),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1074,21 +1133,21 @@ fn decide_to_branching<'a>(
|
||||
cond_layout: Layout<'a>,
|
||||
ret_layout: Layout<'a>,
|
||||
decider: Decider<'a, Choice<'a>>,
|
||||
jumps: &Vec<(u64, Stores<'a>, Expr<'a>)>,
|
||||
) -> (Stores<'a>, Expr<'a>) {
|
||||
jumps: &Vec<(u64, Stmt<'a>)>,
|
||||
) -> Stmt<'a> {
|
||||
use Choice::*;
|
||||
use Decider::*;
|
||||
|
||||
match decider {
|
||||
Leaf(Jump(label)) => {
|
||||
// we currently inline the jumps: does fewer jumps but produces a larger artifact
|
||||
let (_, stores, expr) = jumps
|
||||
let (_, expr) = jumps
|
||||
.iter()
|
||||
.find(|(l, _, _)| l == &label)
|
||||
.find(|(l, _)| l == &label)
|
||||
.expect("jump not in list of jumps");
|
||||
(stores, expr.clone())
|
||||
expr.clone()
|
||||
}
|
||||
Leaf(Inline(stores, expr)) => (stores, expr),
|
||||
Leaf(Inline(expr)) => expr,
|
||||
Chain {
|
||||
test_chain,
|
||||
success,
|
||||
@ -1096,13 +1155,7 @@ fn decide_to_branching<'a>(
|
||||
} => {
|
||||
// generate a switch based on the test chain
|
||||
|
||||
let mut tests = Vec::with_capacity(test_chain.len());
|
||||
|
||||
for (path, test) in test_chain {
|
||||
test_to_equality(env, cond_symbol, &cond_layout, &path, test, &mut tests);
|
||||
}
|
||||
|
||||
let (pass_stores, pass_expr) = decide_to_branching(
|
||||
let pass_expr = decide_to_branching(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout.clone(),
|
||||
@ -1111,7 +1164,7 @@ fn decide_to_branching<'a>(
|
||||
jumps,
|
||||
);
|
||||
|
||||
let (fail_stores, fail_expr) = decide_to_branching(
|
||||
let fail_expr = decide_to_branching(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout.clone(),
|
||||
@ -1120,31 +1173,148 @@ fn decide_to_branching<'a>(
|
||||
jumps,
|
||||
);
|
||||
|
||||
let fail = (fail_stores, &*env.arena.alloc(fail_expr));
|
||||
let pass = (pass_stores, &*env.arena.alloc(pass_expr));
|
||||
let fail = &*env.arena.alloc(fail_expr);
|
||||
let pass = &*env.arena.alloc(pass_expr);
|
||||
|
||||
let condition = boolean_all(env.arena, tests);
|
||||
// TODO totally wrong
|
||||
let condition = Expr::Literal(Literal::Int(42));
|
||||
|
||||
let branching_symbol = env.unique_symbol();
|
||||
let stores = [(branching_symbol, Layout::Builtin(Builtin::Int1), condition)];
|
||||
|
||||
let branching_layout = Layout::Builtin(Builtin::Int1);
|
||||
|
||||
(
|
||||
env.arena.alloc(stores),
|
||||
Expr::Store(
|
||||
&[],
|
||||
env.arena.alloc(Expr::Cond {
|
||||
let mut cond = Stmt::Cond {
|
||||
cond_symbol,
|
||||
cond_layout: cond_layout.clone(),
|
||||
branching_symbol,
|
||||
branching_layout,
|
||||
pass,
|
||||
fail,
|
||||
ret_layout,
|
||||
};
|
||||
|
||||
let true_symbol = env.unique_symbol();
|
||||
|
||||
let mut tests = Vec::with_capacity(test_chain.len());
|
||||
|
||||
let mut guard = None;
|
||||
|
||||
// Assumption: there is at most 1 guard, and it is the outer layer.
|
||||
for (path, test) in test_chain {
|
||||
match test {
|
||||
Test::Guarded {
|
||||
opt_test,
|
||||
id,
|
||||
symbol,
|
||||
stmt,
|
||||
} => {
|
||||
if let Some(nested) = opt_test {
|
||||
tests.push(test_to_equality(
|
||||
env,
|
||||
cond_symbol,
|
||||
&cond_layout,
|
||||
&path,
|
||||
*nested,
|
||||
));
|
||||
}
|
||||
|
||||
// let (stores, rhs_symbol) = path_to_expr(env, cond_symbol, &path, &cond_layout);
|
||||
|
||||
guard = Some((symbol, id, stmt));
|
||||
}
|
||||
|
||||
_ => tests.push(test_to_equality(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout,
|
||||
branching_symbol,
|
||||
branching_layout,
|
||||
pass,
|
||||
fail,
|
||||
ret_layout,
|
||||
}),
|
||||
),
|
||||
)
|
||||
&cond_layout,
|
||||
&path,
|
||||
test,
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
let mut current_symbol = branching_symbol;
|
||||
|
||||
// TODO There must be some way to remove this iterator/loop
|
||||
let nr = (tests.len() as i64) - 1 + (guard.is_some() as i64);
|
||||
let accum_symbols = std::iter::once(true_symbol)
|
||||
.chain((0..nr).map(|_| env.unique_symbol()))
|
||||
.rev()
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let mut accum_it = accum_symbols.into_iter();
|
||||
|
||||
// the guard is the final thing that we check, so needs to be layered on first!
|
||||
if let Some((_, id, stmt)) = guard {
|
||||
let accum = accum_it.next().unwrap();
|
||||
let test_symbol = env.unique_symbol();
|
||||
|
||||
let and_expr =
|
||||
Expr::RunLowLevel(LowLevel::And, env.arena.alloc([test_symbol, accum]));
|
||||
|
||||
// write to the branching symbol
|
||||
cond = Stmt::Let(
|
||||
current_symbol,
|
||||
and_expr,
|
||||
Layout::Builtin(Builtin::Int1),
|
||||
env.arena.alloc(cond),
|
||||
);
|
||||
|
||||
// calculate the guard value
|
||||
cond = Stmt::Join {
|
||||
id,
|
||||
arguments: env
|
||||
.arena
|
||||
.alloc([(test_symbol, Layout::Builtin(Builtin::Int1))]),
|
||||
remainder: env.arena.alloc(stmt),
|
||||
continuation: env.arena.alloc(cond),
|
||||
};
|
||||
|
||||
current_symbol = accum;
|
||||
}
|
||||
|
||||
for ((new_stores, lhs, rhs, layout), accum) in tests.into_iter().rev().zip(accum_it) {
|
||||
let test_symbol = env.unique_symbol();
|
||||
let test = Expr::RunLowLevel(
|
||||
LowLevel::Eq,
|
||||
bumpalo::vec![in env.arena; lhs, rhs].into_bump_slice(),
|
||||
);
|
||||
|
||||
let and_expr =
|
||||
Expr::RunLowLevel(LowLevel::And, env.arena.alloc([test_symbol, accum]));
|
||||
|
||||
// write to the branching symbol
|
||||
cond = Stmt::Let(
|
||||
current_symbol,
|
||||
and_expr,
|
||||
Layout::Builtin(Builtin::Int1),
|
||||
env.arena.alloc(cond),
|
||||
);
|
||||
|
||||
// write to the test symbol
|
||||
cond = Stmt::Let(
|
||||
test_symbol,
|
||||
test,
|
||||
Layout::Builtin(Builtin::Int1),
|
||||
env.arena.alloc(cond),
|
||||
);
|
||||
|
||||
for (symbol, layout, expr) in new_stores.into_iter() {
|
||||
cond = Stmt::Let(symbol, expr, layout, env.arena.alloc(cond));
|
||||
}
|
||||
|
||||
current_symbol = accum;
|
||||
}
|
||||
|
||||
cond = Stmt::Let(
|
||||
true_symbol,
|
||||
Expr::Literal(Literal::Bool(true)),
|
||||
Layout::Builtin(Builtin::Int1),
|
||||
env.arena.alloc(cond),
|
||||
);
|
||||
|
||||
// (env.arena.alloc(stores), cond)
|
||||
cond
|
||||
}
|
||||
FanOut {
|
||||
path,
|
||||
@ -1153,9 +1323,11 @@ fn decide_to_branching<'a>(
|
||||
} => {
|
||||
// the cond_layout can change in the process. E.g. if the cond is a Tag, we actually
|
||||
// switch on the tag discriminant (currently an i64 value)
|
||||
let (cond, cond_layout) = path_to_expr_help(env, cond_symbol, &path, cond_layout);
|
||||
// NOTE the tag discriminant is not actually loaded, `cond` can point to a tag
|
||||
let (cond, cond_stores_vec, cond_layout) =
|
||||
path_to_expr_help2(env, cond_symbol, &path, cond_layout);
|
||||
|
||||
let (default_stores, default_expr) = decide_to_branching(
|
||||
let default_branch = decide_to_branching(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout.clone(),
|
||||
@ -1163,12 +1335,11 @@ fn decide_to_branching<'a>(
|
||||
*fallback,
|
||||
jumps,
|
||||
);
|
||||
let default_branch = (default_stores, &*env.arena.alloc(default_expr));
|
||||
|
||||
let mut branches = bumpalo::collections::Vec::with_capacity_in(tests.len(), env.arena);
|
||||
|
||||
for (test, decider) in tests {
|
||||
let (stores, branch) = decide_to_branching(
|
||||
let branch = decide_to_branching(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout.clone(),
|
||||
@ -1186,25 +1357,28 @@ fn decide_to_branching<'a>(
|
||||
other => todo!("other {:?}", other),
|
||||
};
|
||||
|
||||
branches.push((tag, stores, branch));
|
||||
branches.push((tag, branch));
|
||||
}
|
||||
|
||||
let mut switch = Stmt::Switch {
|
||||
cond_layout,
|
||||
cond_symbol: cond,
|
||||
branches: branches.into_bump_slice(),
|
||||
default_branch: env.arena.alloc(default_branch),
|
||||
ret_layout,
|
||||
};
|
||||
|
||||
for (symbol, layout, expr) in cond_stores_vec.into_iter() {
|
||||
switch = Stmt::Let(symbol, expr, layout, env.arena.alloc(switch));
|
||||
}
|
||||
|
||||
// make a jump table based on the tests
|
||||
(
|
||||
&[],
|
||||
Expr::Switch {
|
||||
cond: env.arena.alloc(cond),
|
||||
cond_layout,
|
||||
cond_symbol,
|
||||
branches: branches.into_bump_slice(),
|
||||
default_branch,
|
||||
ret_layout,
|
||||
},
|
||||
)
|
||||
switch
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
fn boolean_all<'a>(arena: &'a Bump, tests: Vec<(Expr<'a>, Expr<'a>, Layout<'a>)>) -> Expr<'a> {
|
||||
let mut expr = Expr::Bool(true);
|
||||
|
||||
@ -1225,6 +1399,7 @@ fn boolean_all<'a>(arena: &'a Bump, tests: Vec<(Expr<'a>, Expr<'a>, Layout<'a>)>
|
||||
|
||||
expr
|
||||
}
|
||||
*/
|
||||
|
||||
/// TREE TO DECIDER
|
||||
///
|
||||
@ -1398,19 +1573,15 @@ fn count_targets_help(decision_tree: &Decider<u64>, targets: &mut MutMap<u64, u6
|
||||
fn create_choices<'a>(
|
||||
target_counts: &MutMap<u64, u64>,
|
||||
target: u64,
|
||||
stores: Stores<'a>,
|
||||
branch: Expr<'a>,
|
||||
) -> ((u64, Choice<'a>), Option<(u64, Stores<'a>, Expr<'a>)>) {
|
||||
branch: Stmt<'a>,
|
||||
) -> ((u64, Choice<'a>), Option<(u64, Stmt<'a>)>) {
|
||||
match target_counts.get(&target) {
|
||||
None => unreachable!(
|
||||
"this should never happen: {:?} not in {:?}",
|
||||
target, target_counts
|
||||
),
|
||||
Some(1) => ((target, Choice::Inline(stores, branch)), None),
|
||||
Some(_) => (
|
||||
(target, Choice::Jump(target)),
|
||||
Some((target, stores, branch)),
|
||||
),
|
||||
Some(1) => ((target, Choice::Inline(branch)), None),
|
||||
Some(_) => ((target, Choice::Jump(target)), Some((target, branch))),
|
||||
}
|
||||
}
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1971,7 +1971,7 @@ fn from_can_when<'a>(
|
||||
}
|
||||
};
|
||||
|
||||
use crate::decision_tree2::Guard;
|
||||
use crate::decision_tree::Guard;
|
||||
match res_stores {
|
||||
Ok(_) => {
|
||||
for (symbol, layout, expr) in stores.iter().rev() {
|
||||
@ -2008,7 +2008,7 @@ fn from_can_when<'a>(
|
||||
});
|
||||
let mono_branches = Vec::from_iter_in(it, arena);
|
||||
|
||||
crate::decision_tree2::optimize_when(
|
||||
crate::decision_tree::optimize_when(
|
||||
env,
|
||||
cond_symbol,
|
||||
cond_layout.clone(),
|
||||
|
@ -19,6 +19,6 @@ pub mod layout;
|
||||
//#[allow(clippy::ptr_arg)]
|
||||
//pub mod decision_tree;
|
||||
#[allow(clippy::ptr_arg)]
|
||||
pub mod decision_tree2;
|
||||
pub mod decision_tree;
|
||||
#[allow(clippy::ptr_arg)]
|
||||
pub mod exhaustive;
|
||||
|
@ -1,535 +0,0 @@
|
||||
use crate::expr::DestructType;
|
||||
use roc_collections::all::{Index, MutMap};
|
||||
use roc_module::ident::{Lowercase, TagName};
|
||||
use roc_region::all::{Located, Region};
|
||||
|
||||
use self::Pattern::*;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
pub struct Union {
|
||||
pub alternatives: Vec<Ctor>,
|
||||
pub render_as: RenderAs,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum RenderAs {
|
||||
Tag,
|
||||
Record(Vec<Lowercase>),
|
||||
Guard,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash, Copy)]
|
||||
pub struct TagId(pub u8);
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
pub struct Ctor {
|
||||
pub name: TagName,
|
||||
pub tag_id: TagId,
|
||||
pub arity: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Pattern {
|
||||
Anything,
|
||||
Literal(Literal),
|
||||
Ctor(Union, TagId, std::vec::Vec<Pattern>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Literal {
|
||||
Int(i64),
|
||||
Bit(bool),
|
||||
Byte(u8),
|
||||
Float(u64),
|
||||
Str(Box<str>),
|
||||
}
|
||||
|
||||
fn simplify<'a>(pattern: &crate::expr::Pattern<'a>) -> Pattern {
|
||||
use crate::expr::Pattern::*;
|
||||
|
||||
match pattern {
|
||||
IntLiteral(v) => Literal(Literal::Int(*v)),
|
||||
FloatLiteral(v) => Literal(Literal::Float(*v)),
|
||||
StrLiteral(v) => Literal(Literal::Str(v.clone())),
|
||||
|
||||
// To make sure these are exhaustive, we have to "fake" a union here
|
||||
// TODO: use the hash or some other integer to discriminate between constructors
|
||||
BitLiteral { value, union, .. } => Ctor(union.clone(), TagId(*value as u8), vec![]),
|
||||
EnumLiteral { tag_id, union, .. } => Ctor(union.clone(), TagId(*tag_id), vec![]),
|
||||
|
||||
Underscore => Anything,
|
||||
Identifier(_) => Anything,
|
||||
RecordDestructure(destructures, _) => {
|
||||
let tag_id = TagId(0);
|
||||
let mut patterns = std::vec::Vec::with_capacity(destructures.len());
|
||||
let mut field_names = std::vec::Vec::with_capacity(destructures.len());
|
||||
|
||||
for destruct in destructures {
|
||||
field_names.push(destruct.label.clone());
|
||||
|
||||
match &destruct.typ {
|
||||
DestructType::Required | DestructType::Optional(_) => patterns.push(Anything),
|
||||
DestructType::Guard(guard) => patterns.push(simplify(guard)),
|
||||
}
|
||||
}
|
||||
|
||||
let union = Union {
|
||||
render_as: RenderAs::Record(field_names),
|
||||
alternatives: vec![Ctor {
|
||||
name: TagName::Global("#Record".into()),
|
||||
tag_id,
|
||||
arity: destructures.len(),
|
||||
}],
|
||||
};
|
||||
|
||||
Ctor(union, tag_id, patterns)
|
||||
}
|
||||
|
||||
Shadowed(_region, _ident) => {
|
||||
// Treat as an Anything
|
||||
// code-gen will make a runtime error out of the branch
|
||||
Anything
|
||||
}
|
||||
UnsupportedPattern(_region) => {
|
||||
// Treat as an Anything
|
||||
// code-gen will make a runtime error out of the branch
|
||||
Anything
|
||||
}
|
||||
|
||||
AppliedTag {
|
||||
tag_id,
|
||||
arguments,
|
||||
union,
|
||||
..
|
||||
} => {
|
||||
let simplified_args: std::vec::Vec<_> =
|
||||
arguments.iter().map(|v| simplify(&v.0)).collect();
|
||||
Ctor(union.clone(), TagId(*tag_id), simplified_args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Error
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Error {
|
||||
Incomplete(Region, Context, Vec<Pattern>),
|
||||
Redundant {
|
||||
overall_region: Region,
|
||||
branch_region: Region,
|
||||
index: Index,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Context {
|
||||
BadArg,
|
||||
BadDestruct,
|
||||
BadCase,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Guard {
|
||||
HasGuard,
|
||||
NoGuard,
|
||||
}
|
||||
|
||||
/// Check
|
||||
|
||||
pub fn check<'a>(
|
||||
region: Region,
|
||||
patterns: &[(Located<crate::expr::Pattern<'a>>, Guard)],
|
||||
context: Context,
|
||||
) -> Result<(), Vec<Error>> {
|
||||
let mut errors = Vec::new();
|
||||
check_patterns(region, context, patterns, &mut errors);
|
||||
|
||||
if errors.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(errors)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn check_patterns<'a>(
|
||||
region: Region,
|
||||
context: Context,
|
||||
patterns: &[(Located<crate::expr::Pattern<'a>>, Guard)],
|
||||
errors: &mut Vec<Error>,
|
||||
) {
|
||||
match to_nonredundant_rows(region, patterns) {
|
||||
Err(err) => errors.push(err),
|
||||
Ok(matrix) => {
|
||||
let bad_patterns = is_exhaustive(&matrix, 1);
|
||||
if !bad_patterns.is_empty() {
|
||||
// TODO i suspect this is like a concat in in practice? code below can panic
|
||||
// if this debug_assert! ever fails, the theory is disproven
|
||||
debug_assert!(
|
||||
bad_patterns.iter().map(|v| v.len()).sum::<usize>() == bad_patterns.len()
|
||||
);
|
||||
let heads = bad_patterns.into_iter().map(|mut v| v.remove(0)).collect();
|
||||
errors.push(Error::Incomplete(region, context, heads));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// EXHAUSTIVE PATTERNS
|
||||
|
||||
/// INVARIANTS:
|
||||
///
|
||||
/// The initial rows "matrix" are all of length 1
|
||||
/// The initial count of items per row "n" is also 1
|
||||
/// The resulting rows are examples of missing patterns
|
||||
fn is_exhaustive(matrix: &PatternMatrix, n: usize) -> PatternMatrix {
|
||||
if matrix.is_empty() {
|
||||
vec![std::iter::repeat(Anything).take(n).collect()]
|
||||
} else if n == 0 {
|
||||
vec![]
|
||||
} else {
|
||||
let ctors = collect_ctors(matrix);
|
||||
let num_seen = ctors.len();
|
||||
|
||||
if num_seen == 0 {
|
||||
let new_matrix = matrix
|
||||
.iter()
|
||||
.filter_map(specialize_row_by_anything)
|
||||
.collect();
|
||||
let mut rest = is_exhaustive(&new_matrix, n - 1);
|
||||
|
||||
for row in rest.iter_mut() {
|
||||
row.push(Anything);
|
||||
}
|
||||
|
||||
rest
|
||||
} else {
|
||||
let alts = ctors.iter().next().unwrap().1;
|
||||
|
||||
let alt_list = &alts.alternatives;
|
||||
let num_alts = alt_list.len();
|
||||
|
||||
if num_seen < num_alts {
|
||||
let new_matrix = matrix
|
||||
.iter()
|
||||
.filter_map(specialize_row_by_anything)
|
||||
.collect();
|
||||
let rest: Vec<Vec<Pattern>> = is_exhaustive(&new_matrix, n - 1);
|
||||
|
||||
let last: _ = alt_list
|
||||
.iter()
|
||||
.filter_map(|r| is_missing(alts.clone(), ctors.clone(), r));
|
||||
|
||||
let mut result = Vec::new();
|
||||
|
||||
for last_option in last {
|
||||
for mut row in rest.clone() {
|
||||
row.push(last_option.clone());
|
||||
|
||||
result.push(row);
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
} else {
|
||||
let is_alt_exhaustive = |Ctor { arity, tag_id, .. }| {
|
||||
let new_matrix = matrix
|
||||
.iter()
|
||||
.filter_map(|r| specialize_row_by_ctor(tag_id, arity, r))
|
||||
.collect();
|
||||
let rest: Vec<Vec<Pattern>> = is_exhaustive(&new_matrix, arity + n - 1);
|
||||
|
||||
let mut result = Vec::with_capacity(rest.len());
|
||||
for row in rest {
|
||||
result.push(recover_ctor(alts.clone(), tag_id, arity, row));
|
||||
}
|
||||
|
||||
result
|
||||
};
|
||||
|
||||
alt_list
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(is_alt_exhaustive)
|
||||
.flatten()
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_missing<T>(union: Union, ctors: MutMap<TagId, T>, ctor: &Ctor) -> Option<Pattern> {
|
||||
let Ctor { arity, tag_id, .. } = ctor;
|
||||
|
||||
if ctors.contains_key(tag_id) {
|
||||
None
|
||||
} else {
|
||||
let anythings = std::iter::repeat(Anything).take(*arity).collect();
|
||||
Some(Pattern::Ctor(union, *tag_id, anythings))
|
||||
}
|
||||
}
|
||||
|
||||
fn recover_ctor(
|
||||
union: Union,
|
||||
tag_id: TagId,
|
||||
arity: usize,
|
||||
mut patterns: Vec<Pattern>,
|
||||
) -> Vec<Pattern> {
|
||||
let mut rest = patterns.split_off(arity);
|
||||
let args = patterns;
|
||||
|
||||
rest.push(Ctor(union, tag_id, args));
|
||||
|
||||
rest
|
||||
}
|
||||
|
||||
/// REDUNDANT PATTERNS
|
||||
|
||||
/// INVARIANT: Produces a list of rows where (forall row. length row == 1)
|
||||
fn to_nonredundant_rows<'a>(
|
||||
overall_region: Region,
|
||||
patterns: &[(Located<crate::expr::Pattern<'a>>, Guard)],
|
||||
) -> Result<Vec<Vec<Pattern>>, Error> {
|
||||
let mut checked_rows = Vec::with_capacity(patterns.len());
|
||||
|
||||
// If any of the branches has a guard, e.g.
|
||||
//
|
||||
// when x is
|
||||
// y if y < 10 -> "foo"
|
||||
// _ -> "bar"
|
||||
//
|
||||
// then we treat it as a pattern match on the pattern and a boolean, wrapped in the #Guard
|
||||
// constructor. We can use this special constructor name to generate better error messages.
|
||||
// This transformation of the pattern match only works because we only report exhaustiveness
|
||||
// errors: the Pattern created in this file is not used for code gen.
|
||||
//
|
||||
// when x is
|
||||
// #Guard y True -> "foo"
|
||||
// #Guard _ _ -> "bar"
|
||||
let any_has_guard = patterns.iter().any(|(_, guard)| guard == &Guard::HasGuard);
|
||||
|
||||
for (loc_pat, guard) in patterns {
|
||||
let region = loc_pat.region;
|
||||
|
||||
let next_row = if any_has_guard {
|
||||
let guard_pattern = match guard {
|
||||
Guard::HasGuard => Pattern::Literal(Literal::Bit(true)),
|
||||
Guard::NoGuard => Pattern::Anything,
|
||||
};
|
||||
|
||||
let tag_id = TagId(0);
|
||||
|
||||
let union = Union {
|
||||
render_as: RenderAs::Guard,
|
||||
alternatives: vec![Ctor {
|
||||
tag_id,
|
||||
name: TagName::Global("#Guard".into()),
|
||||
arity: 2,
|
||||
}],
|
||||
};
|
||||
|
||||
vec![Pattern::Ctor(
|
||||
union,
|
||||
tag_id,
|
||||
vec![simplify(&loc_pat.value), guard_pattern],
|
||||
)]
|
||||
} else {
|
||||
vec![simplify(&loc_pat.value)]
|
||||
};
|
||||
|
||||
if is_useful(&checked_rows, &next_row) {
|
||||
checked_rows.push(next_row);
|
||||
} else {
|
||||
return Err(Error::Redundant {
|
||||
overall_region,
|
||||
branch_region: region,
|
||||
index: Index::zero_based(checked_rows.len()),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
Ok(checked_rows)
|
||||
}
|
||||
|
||||
/// Check if a new row "vector" is useful given previous rows "matrix"
|
||||
fn is_useful(matrix: &PatternMatrix, vector: &Row) -> bool {
|
||||
if matrix.is_empty() {
|
||||
// No rows are the same as the new vector! The vector is useful!
|
||||
true
|
||||
} else if vector.is_empty() {
|
||||
// There is nothing left in the new vector, but we still have
|
||||
// rows that match the same things. This is not a useful vector!
|
||||
false
|
||||
} else {
|
||||
// NOTE: if there are bugs in this code, look at the ordering of the row/matrix
|
||||
let mut vector = vector.clone();
|
||||
let first_pattern = vector.remove(0);
|
||||
let patterns = vector;
|
||||
|
||||
match first_pattern {
|
||||
// keep checking rows that start with this Ctor or Anything
|
||||
Ctor(_, id, args) => {
|
||||
let new_matrix: Vec<_> = matrix
|
||||
.iter()
|
||||
.filter_map(|r| specialize_row_by_ctor(id, args.len(), r))
|
||||
.collect();
|
||||
|
||||
let mut new_row = Vec::new();
|
||||
new_row.extend(patterns);
|
||||
new_row.extend(args);
|
||||
|
||||
is_useful(&new_matrix, &new_row)
|
||||
}
|
||||
|
||||
Anything => {
|
||||
// check if all alts appear in matrix
|
||||
match is_complete(matrix) {
|
||||
Complete::No => {
|
||||
// This Anything is useful because some Ctors are missing.
|
||||
// But what if a previous row has an Anything?
|
||||
// If so, this one is not useful.
|
||||
let new_matrix: Vec<_> = matrix
|
||||
.iter()
|
||||
.filter_map(|r| specialize_row_by_anything(r))
|
||||
.collect();
|
||||
|
||||
is_useful(&new_matrix, &patterns)
|
||||
}
|
||||
Complete::Yes(alts) => {
|
||||
// All Ctors are covered, so this Anything is not needed for any
|
||||
// of those. But what if some of those Ctors have subpatterns
|
||||
// that make them less general? If so, this actually is useful!
|
||||
let is_useful_alt = |Ctor { arity, tag_id, .. }| {
|
||||
let new_matrix = matrix
|
||||
.iter()
|
||||
.filter_map(|r| specialize_row_by_ctor(tag_id, arity, r))
|
||||
.collect();
|
||||
let mut new_row: Vec<Pattern> =
|
||||
std::iter::repeat(Anything).take(arity).collect::<Vec<_>>();
|
||||
|
||||
new_row.extend(patterns.clone());
|
||||
|
||||
is_useful(&new_matrix, &new_row)
|
||||
};
|
||||
|
||||
alts.iter().cloned().any(is_useful_alt)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Literal(literal) => {
|
||||
// keep checking rows that start with this Literal or Anything
|
||||
let new_matrix = matrix
|
||||
.iter()
|
||||
.filter_map(|r| specialize_row_by_literal(&literal, r))
|
||||
.collect();
|
||||
is_useful(&new_matrix, &patterns)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// INVARIANT: (length row == N) ==> (length result == arity + N - 1)
|
||||
fn specialize_row_by_ctor(tag_id: TagId, arity: usize, row: &Row) -> Option<Row> {
|
||||
let mut row = row.clone();
|
||||
|
||||
let head = row.pop();
|
||||
let patterns = row;
|
||||
|
||||
match head {
|
||||
Some(Ctor(_, id, args)) =>
|
||||
if id == tag_id {
|
||||
// TODO order!
|
||||
let mut new_patterns = Vec::new();
|
||||
new_patterns.extend(args);
|
||||
new_patterns.extend(patterns);
|
||||
Some(new_patterns)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
Some(Anything) => {
|
||||
// TODO order!
|
||||
let new_patterns =
|
||||
std::iter::repeat(Anything).take(arity).chain(patterns).collect();
|
||||
Some(new_patterns)
|
||||
}
|
||||
Some(Literal(_)) => panic!( "Compiler bug! After type checking, constructors and literal should never align in pattern match exhaustiveness checks."),
|
||||
None => panic!("Compiler error! Empty matrices should not get specialized."),
|
||||
}
|
||||
}
|
||||
|
||||
/// INVARIANT: (length row == N) ==> (length result == N-1)
|
||||
fn specialize_row_by_literal(literal: &Literal, row: &Row) -> Option<Row> {
|
||||
let mut row = row.clone();
|
||||
|
||||
let head = row.pop();
|
||||
let patterns = row;
|
||||
|
||||
match head {
|
||||
Some(Literal(lit)) => {
|
||||
if &lit == literal {
|
||||
Some(patterns)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
Some(Anything) => Some(patterns),
|
||||
|
||||
Some(Ctor(_, _, _)) => panic!(
|
||||
r#"Compiler bug! After type checking, constructors and literals should never align in pattern match exhaustiveness checks."#
|
||||
),
|
||||
|
||||
None => panic!("Compiler error! Empty matrices should not get specialized."),
|
||||
}
|
||||
}
|
||||
|
||||
/// INVARIANT: (length row == N) ==> (length result == N-1)
|
||||
fn specialize_row_by_anything(row: &Row) -> Option<Row> {
|
||||
let mut row = row.clone();
|
||||
|
||||
match row.pop() {
|
||||
Some(Anything) => Some(row),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// ALL CONSTRUCTORS ARE PRESENT?
|
||||
|
||||
pub enum Complete {
|
||||
Yes(Vec<Ctor>),
|
||||
No,
|
||||
}
|
||||
|
||||
fn is_complete(matrix: &PatternMatrix) -> Complete {
|
||||
let ctors = collect_ctors(matrix);
|
||||
|
||||
let mut it = ctors.values();
|
||||
|
||||
match it.next() {
|
||||
None => Complete::No,
|
||||
Some(Union { alternatives, .. }) => {
|
||||
if ctors.len() == alternatives.len() {
|
||||
Complete::Yes(alternatives.to_vec())
|
||||
} else {
|
||||
Complete::No
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// COLLECT CTORS
|
||||
|
||||
type RefPatternMatrix = [Vec<Pattern>];
|
||||
type PatternMatrix = Vec<Vec<Pattern>>;
|
||||
type Row = Vec<Pattern>;
|
||||
|
||||
fn collect_ctors(matrix: &RefPatternMatrix) -> MutMap<TagId, Union> {
|
||||
let mut ctors = MutMap::default();
|
||||
|
||||
for row in matrix {
|
||||
if let Some(Ctor(union, id, _)) = row.get(row.len() - 1) {
|
||||
ctors.insert(*id, union.clone());
|
||||
}
|
||||
}
|
||||
|
||||
ctors
|
||||
}
|
Loading…
Reference in New Issue
Block a user