mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-28 14:24:45 +00:00
Remove unused code
This commit is contained in:
JRI98
parent
54e78e8fd4
commit
90f517712a
33 changed files with 24 additions and 1300 deletions
|
|
@ -1,7 +1,6 @@
|
|||
use crate::abilities::SpecializationId;
|
||||
use crate::annotation::{freshen_opaque_def, IntroducedVariables};
|
||||
use crate::builtins::builtin_defs_map;
|
||||
use crate::def::{can_defs_with_return, Annotation, Def, DefKind};
|
||||
use crate::def::{can_defs_with_return, Annotation, Def};
|
||||
use crate::env::Env;
|
||||
use crate::num::{
|
||||
finish_parsing_base, finish_parsing_float, finish_parsing_num, float_expr_from_result,
|
||||
|
|
@ -344,14 +343,6 @@ pub struct ExpectLookup {
|
|||
pub ability_info: Option<SpecializationId>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct DbgLookup {
|
||||
pub symbol: Symbol,
|
||||
pub var: Variable,
|
||||
pub region: Region,
|
||||
pub ability_info: Option<SpecializationId>,
|
||||
}
|
||||
|
||||
impl Expr {
|
||||
pub fn category(&self) -> Category {
|
||||
match self {
|
||||
|
|
@ -750,36 +741,6 @@ pub struct WhenBranch {
|
|||
pub redundant: RedundantMark,
|
||||
}
|
||||
|
||||
impl WhenBranch {
|
||||
pub fn pattern_region(&self) -> Region {
|
||||
Region::span_across(
|
||||
&self
|
||||
.patterns
|
||||
.first()
|
||||
.expect("when branch has no pattern?")
|
||||
.pattern
|
||||
.region,
|
||||
&self
|
||||
.patterns
|
||||
.last()
|
||||
.expect("when branch has no pattern?")
|
||||
.pattern
|
||||
.region,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl WhenBranch {
|
||||
pub fn region(&self) -> Region {
|
||||
Region::across_all(
|
||||
self.patterns
|
||||
.iter()
|
||||
.map(|p| &p.pattern.region)
|
||||
.chain([self.value.region].iter()),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn canonicalize_expr<'a>(
|
||||
env: &mut Env<'a>,
|
||||
var_store: &mut VarStore,
|
||||
|
|
@ -2171,446 +2132,6 @@ fn lookup_to_expr(
|
|||
}
|
||||
}
|
||||
|
||||
/// Currently uses the heuristic of "only inline if it's a builtin"
|
||||
pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
|
||||
use Expr::*;
|
||||
|
||||
match expr {
|
||||
// Num stores the `a` variable in `Num a`. Not the same as the variable
|
||||
// stored in Int and Float below, which is strictly for better error messages
|
||||
other @ Num(..)
|
||||
| other @ Int(..)
|
||||
| other @ Float(..)
|
||||
| other @ Str { .. }
|
||||
| other @ IngestedFile(..)
|
||||
| other @ SingleQuote(..)
|
||||
| other @ RuntimeError(_)
|
||||
| other @ EmptyRecord
|
||||
| other @ RecordAccessor { .. }
|
||||
| other @ RecordUpdate { .. }
|
||||
| other @ Var(..)
|
||||
| other @ ParamsVar { .. }
|
||||
| other @ AbilityMember(..)
|
||||
| other @ RunLowLevel { .. }
|
||||
| other @ ForeignCall { .. }
|
||||
| other @ OpaqueWrapFunction(_)
|
||||
| other @ Crash { .. }
|
||||
| other @ Return { .. } => other,
|
||||
|
||||
List {
|
||||
elem_var,
|
||||
loc_elems,
|
||||
} => {
|
||||
let mut new_elems = Vec::with_capacity(loc_elems.len());
|
||||
|
||||
for loc_elem in loc_elems {
|
||||
let value = inline_calls(var_store, loc_elem.value);
|
||||
|
||||
new_elems.push(Loc {
|
||||
value,
|
||||
region: loc_elem.region,
|
||||
});
|
||||
}
|
||||
|
||||
List {
|
||||
elem_var,
|
||||
loc_elems: new_elems,
|
||||
}
|
||||
}
|
||||
// Branching
|
||||
When {
|
||||
cond_var,
|
||||
expr_var,
|
||||
region,
|
||||
loc_cond,
|
||||
branches,
|
||||
branches_cond_var,
|
||||
exhaustive,
|
||||
} => {
|
||||
let loc_cond = Box::new(Loc {
|
||||
region: loc_cond.region,
|
||||
value: inline_calls(var_store, loc_cond.value),
|
||||
});
|
||||
|
||||
let mut new_branches = Vec::with_capacity(branches.len());
|
||||
|
||||
for branch in branches {
|
||||
let value = Loc {
|
||||
value: inline_calls(var_store, branch.value.value),
|
||||
region: branch.value.region,
|
||||
};
|
||||
let guard = match branch.guard {
|
||||
Some(loc_expr) => Some(Loc {
|
||||
region: loc_expr.region,
|
||||
value: inline_calls(var_store, loc_expr.value),
|
||||
}),
|
||||
None => None,
|
||||
};
|
||||
let new_branch = WhenBranch {
|
||||
patterns: branch.patterns,
|
||||
value,
|
||||
guard,
|
||||
redundant: RedundantMark::new(var_store),
|
||||
};
|
||||
|
||||
new_branches.push(new_branch);
|
||||
}
|
||||
|
||||
When {
|
||||
cond_var,
|
||||
expr_var,
|
||||
region,
|
||||
loc_cond,
|
||||
branches: new_branches,
|
||||
branches_cond_var,
|
||||
exhaustive,
|
||||
}
|
||||
}
|
||||
If {
|
||||
cond_var,
|
||||
branch_var,
|
||||
branches,
|
||||
final_else,
|
||||
} => {
|
||||
let mut new_branches = Vec::with_capacity(branches.len());
|
||||
|
||||
for (loc_cond, loc_expr) in branches {
|
||||
let loc_cond = Loc {
|
||||
value: inline_calls(var_store, loc_cond.value),
|
||||
region: loc_cond.region,
|
||||
};
|
||||
|
||||
let loc_expr = Loc {
|
||||
value: inline_calls(var_store, loc_expr.value),
|
||||
region: loc_expr.region,
|
||||
};
|
||||
|
||||
new_branches.push((loc_cond, loc_expr));
|
||||
}
|
||||
|
||||
let final_else = Box::new(Loc {
|
||||
region: final_else.region,
|
||||
value: inline_calls(var_store, final_else.value),
|
||||
});
|
||||
|
||||
If {
|
||||
cond_var,
|
||||
branch_var,
|
||||
branches: new_branches,
|
||||
final_else,
|
||||
}
|
||||
}
|
||||
|
||||
Expect {
|
||||
loc_condition,
|
||||
loc_continuation,
|
||||
lookups_in_cond,
|
||||
} => {
|
||||
let loc_condition = Loc {
|
||||
region: loc_condition.region,
|
||||
value: inline_calls(var_store, loc_condition.value),
|
||||
};
|
||||
|
||||
let loc_continuation = Loc {
|
||||
region: loc_continuation.region,
|
||||
value: inline_calls(var_store, loc_continuation.value),
|
||||
};
|
||||
|
||||
Expect {
|
||||
loc_condition: Box::new(loc_condition),
|
||||
loc_continuation: Box::new(loc_continuation),
|
||||
lookups_in_cond,
|
||||
}
|
||||
}
|
||||
|
||||
Dbg {
|
||||
source_location,
|
||||
source,
|
||||
loc_message,
|
||||
loc_continuation,
|
||||
variable,
|
||||
symbol,
|
||||
} => {
|
||||
let loc_message = Loc {
|
||||
region: loc_message.region,
|
||||
value: inline_calls(var_store, loc_message.value),
|
||||
};
|
||||
|
||||
let loc_continuation = Loc {
|
||||
region: loc_continuation.region,
|
||||
value: inline_calls(var_store, loc_continuation.value),
|
||||
};
|
||||
|
||||
Dbg {
|
||||
source_location,
|
||||
source,
|
||||
loc_message: Box::new(loc_message),
|
||||
loc_continuation: Box::new(loc_continuation),
|
||||
variable,
|
||||
symbol,
|
||||
}
|
||||
}
|
||||
|
||||
LetRec(defs, loc_expr, mark) => {
|
||||
let mut new_defs = Vec::with_capacity(defs.len());
|
||||
|
||||
for def in defs {
|
||||
new_defs.push(Def {
|
||||
loc_pattern: def.loc_pattern,
|
||||
loc_expr: Loc {
|
||||
region: def.loc_expr.region,
|
||||
value: inline_calls(var_store, def.loc_expr.value),
|
||||
},
|
||||
expr_var: def.expr_var,
|
||||
pattern_vars: def.pattern_vars,
|
||||
annotation: def.annotation,
|
||||
kind: def.kind,
|
||||
});
|
||||
}
|
||||
|
||||
let loc_expr = Loc {
|
||||
region: loc_expr.region,
|
||||
value: inline_calls(var_store, loc_expr.value),
|
||||
};
|
||||
|
||||
LetRec(new_defs, Box::new(loc_expr), mark)
|
||||
}
|
||||
|
||||
LetNonRec(def, loc_expr) => {
|
||||
let def = Def {
|
||||
loc_pattern: def.loc_pattern,
|
||||
loc_expr: Loc {
|
||||
region: def.loc_expr.region,
|
||||
value: inline_calls(var_store, def.loc_expr.value),
|
||||
},
|
||||
expr_var: def.expr_var,
|
||||
pattern_vars: def.pattern_vars,
|
||||
annotation: def.annotation,
|
||||
kind: def.kind,
|
||||
};
|
||||
|
||||
let loc_expr = Loc {
|
||||
region: loc_expr.region,
|
||||
value: inline_calls(var_store, loc_expr.value),
|
||||
};
|
||||
|
||||
LetNonRec(Box::new(def), Box::new(loc_expr))
|
||||
}
|
||||
|
||||
Closure(ClosureData {
|
||||
function_type,
|
||||
closure_type,
|
||||
return_type,
|
||||
fx_type,
|
||||
early_returns,
|
||||
recursive,
|
||||
name,
|
||||
captured_symbols,
|
||||
arguments,
|
||||
loc_body,
|
||||
}) => {
|
||||
let loc_expr = *loc_body;
|
||||
let loc_expr = Loc {
|
||||
value: inline_calls(var_store, loc_expr.value),
|
||||
region: loc_expr.region,
|
||||
};
|
||||
|
||||
Closure(ClosureData {
|
||||
function_type,
|
||||
closure_type,
|
||||
return_type,
|
||||
fx_type,
|
||||
early_returns,
|
||||
recursive,
|
||||
name,
|
||||
captured_symbols,
|
||||
arguments,
|
||||
loc_body: Box::new(loc_expr),
|
||||
})
|
||||
}
|
||||
|
||||
Record { record_var, fields } => {
|
||||
todo!(
|
||||
"Inlining for Record with record_var {:?} and fields {:?}",
|
||||
record_var,
|
||||
fields
|
||||
);
|
||||
}
|
||||
|
||||
ImportParams(module_id, region, Some((var, expr))) => ImportParams(
|
||||
module_id,
|
||||
region,
|
||||
Some((var, Box::new(inline_calls(var_store, *expr)))),
|
||||
),
|
||||
|
||||
ImportParams(module_id, region, None) => ImportParams(module_id, region, None),
|
||||
|
||||
RecordAccess {
|
||||
record_var,
|
||||
ext_var,
|
||||
field_var,
|
||||
loc_expr,
|
||||
field,
|
||||
} => {
|
||||
todo!("Inlining for RecordAccess with record_var {:?}, ext_var {:?}, field_var {:?}, loc_expr {:?}, field {:?}", record_var, ext_var, field_var, loc_expr, field);
|
||||
}
|
||||
|
||||
Tuple { tuple_var, elems } => {
|
||||
todo!(
|
||||
"Inlining for Tuple with tuple_var {:?} and elems {:?}",
|
||||
tuple_var,
|
||||
elems
|
||||
);
|
||||
}
|
||||
|
||||
TupleAccess {
|
||||
tuple_var,
|
||||
ext_var,
|
||||
elem_var,
|
||||
loc_expr,
|
||||
index,
|
||||
} => {
|
||||
todo!("Inlining for TupleAccess with tuple_var {:?}, ext_var {:?}, elem_var {:?}, loc_expr {:?}, index {:?}", tuple_var, ext_var, elem_var, loc_expr, index);
|
||||
}
|
||||
|
||||
Tag {
|
||||
tag_union_var: variant_var,
|
||||
ext_var,
|
||||
name,
|
||||
arguments,
|
||||
} => {
|
||||
todo!(
|
||||
"Inlining for Tag with variant_var {:?}, ext_var {:?}, name {:?}, arguments {:?}",
|
||||
variant_var,
|
||||
ext_var,
|
||||
name,
|
||||
arguments
|
||||
);
|
||||
}
|
||||
|
||||
OpaqueRef {
|
||||
opaque_var,
|
||||
name,
|
||||
argument,
|
||||
specialized_def_type,
|
||||
type_arguments,
|
||||
lambda_set_variables,
|
||||
} => {
|
||||
let (var, loc_expr) = *argument;
|
||||
let argument = Box::new((
|
||||
var,
|
||||
loc_expr.map_owned(|expr| inline_calls(var_store, expr)),
|
||||
));
|
||||
|
||||
OpaqueRef {
|
||||
opaque_var,
|
||||
name,
|
||||
argument,
|
||||
specialized_def_type,
|
||||
type_arguments,
|
||||
lambda_set_variables,
|
||||
}
|
||||
}
|
||||
|
||||
ZeroArgumentTag {
|
||||
closure_name,
|
||||
variant_var,
|
||||
ext_var,
|
||||
name,
|
||||
} => {
|
||||
todo!(
|
||||
"Inlining for ZeroArgumentTag with closure_name {:?}, variant_var {:?}, ext_var {:?}, name {:?}",
|
||||
closure_name,
|
||||
variant_var,
|
||||
ext_var,
|
||||
name,
|
||||
);
|
||||
}
|
||||
|
||||
Call(boxed_tuple, args, called_via) => {
|
||||
let (fn_var, loc_expr, closure_var, expr_var, fx_var) = *boxed_tuple;
|
||||
|
||||
match loc_expr.value {
|
||||
Var(symbol, _) if symbol.is_builtin() => {
|
||||
// NOTE: This assumes builtins are not effectful!
|
||||
match builtin_defs_map(symbol, var_store) {
|
||||
Some(Def {
|
||||
loc_expr:
|
||||
Loc {
|
||||
value:
|
||||
Closure(ClosureData {
|
||||
recursive,
|
||||
arguments: params,
|
||||
loc_body: boxed_body,
|
||||
..
|
||||
}),
|
||||
..
|
||||
},
|
||||
..
|
||||
}) => {
|
||||
debug_assert_eq!(recursive, Recursive::NotRecursive);
|
||||
|
||||
// Since this is a canonicalized Expr, we should have
|
||||
// already detected any arity mismatches and replaced this
|
||||
// with a RuntimeError if there was a mismatch.
|
||||
debug_assert_eq!(params.len(), args.len());
|
||||
|
||||
// Start with the function's body as the answer.
|
||||
let mut loc_answer = *boxed_body;
|
||||
|
||||
// Wrap the body in one LetNonRec for each argument,
|
||||
// such that at the end we have all the arguments in
|
||||
// scope with the values the caller provided.
|
||||
for (
|
||||
(_param_var, _exhaustive_mark, loc_pattern),
|
||||
(expr_var, loc_expr),
|
||||
) in params.iter().cloned().zip(args.into_iter()).rev()
|
||||
{
|
||||
// TODO get the correct vars into here.
|
||||
// Not sure if param_var should be involved.
|
||||
let pattern_vars = SendMap::default();
|
||||
|
||||
let def = Def {
|
||||
loc_pattern,
|
||||
loc_expr,
|
||||
expr_var,
|
||||
pattern_vars,
|
||||
annotation: None,
|
||||
kind: DefKind::Let,
|
||||
};
|
||||
|
||||
loc_answer = Loc {
|
||||
region: Region::zero(),
|
||||
value: LetNonRec(Box::new(def), Box::new(loc_answer)),
|
||||
};
|
||||
}
|
||||
|
||||
loc_answer.value
|
||||
}
|
||||
Some(_) => {
|
||||
internal_error!("Tried to inline a non-function");
|
||||
}
|
||||
None => {
|
||||
internal_error!(
|
||||
"Tried to inline a builtin that wasn't registered: {:?}",
|
||||
symbol
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// For now, we only inline calls to builtins. Leave this alone!
|
||||
Call(
|
||||
Box::new((fn_var, loc_expr, closure_var, expr_var, fx_var)),
|
||||
args,
|
||||
called_via,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn flatten_str_literal<'a>(
|
||||
env: &mut Env<'a>,
|
||||
var_store: &mut VarStore,
|
||||
|
|
@ -3330,7 +2851,7 @@ impl Declarations {
|
|||
pub fn expects(&self) -> ExpectCollector {
|
||||
let mut collector = ExpectCollector {
|
||||
expects: VecMap::default(),
|
||||
dbgs: VecMap::default(),
|
||||
has_dbgs: false,
|
||||
};
|
||||
|
||||
let var = Variable::EMPTY_RECORD;
|
||||
|
|
@ -3652,7 +3173,7 @@ pub fn toplevel_expect_to_inline_expect_pure(mut loc_expr: Loc<Expr>) -> Loc<Exp
|
|||
|
||||
pub struct ExpectCollector {
|
||||
pub expects: VecMap<Region, Vec<ExpectLookup>>,
|
||||
pub dbgs: VecMap<Symbol, DbgLookup>,
|
||||
pub has_dbgs: bool,
|
||||
}
|
||||
|
||||
impl crate::traverse::Visitor for ExpectCollector {
|
||||
|
|
@ -3666,20 +3187,8 @@ impl crate::traverse::Visitor for ExpectCollector {
|
|||
self.expects
|
||||
.insert(loc_condition.region, lookups_in_cond.to_vec());
|
||||
}
|
||||
Expr::Dbg {
|
||||
loc_message,
|
||||
variable,
|
||||
symbol,
|
||||
..
|
||||
} => {
|
||||
let lookup = DbgLookup {
|
||||
symbol: *symbol,
|
||||
var: *variable,
|
||||
region: loc_message.region,
|
||||
ability_info: None,
|
||||
};
|
||||
|
||||
self.dbgs.insert(*symbol, lookup);
|
||||
Expr::Dbg { .. } => {
|
||||
self.has_dbgs = true;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue