language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-02 03:12:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Shove more into a common env

Browse source
This commit is contained in:
Ayaz Hafiz 2023-06-22 14:06:55 -05:00
parent f8e377a055
commit 15eef74a83
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
2 changed files with 40 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

105
crates/compiler/solve/src/aliases.rs
View file

@ -121,14 +121,8 @@ impl Aliases {
} }
fn instantiate_result_result( fn instantiate_result_result(
<<<<<<< HEAD
env: &mut Env, env: &mut Env,
rank: Rank, rank: Rank,
=======
subs: &mut Subs,
rank: Rank,
pools: &mut Pools,
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
alias_variables: AliasVariables, alias_variables: AliasVariables,
) -> Variable { ) -> Variable {
let tag_names_slice = Subs::RESULT_TAG_NAMES; let tag_names_slice = Subs::RESULT_TAG_NAMES;
@ -137,85 +131,49 @@ impl Aliases {
let ok_slice = SubsSlice::new(alias_variables.variables_start, 1); let ok_slice = SubsSlice::new(alias_variables.variables_start, 1);
let variable_slices = let variable_slices =
<<<<<<< HEAD
SubsSlice::extend_new(&mut env.subs.variable_slices, [err_slice, ok_slice]); SubsSlice::extend_new(&mut env.subs.variable_slices, [err_slice, ok_slice]);
=======
SubsSlice::extend_new(&mut subs.variable_slices, [err_slice, ok_slice]);
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
let union_tags = UnionTags::from_slices(tag_names_slice, variable_slices); let union_tags = UnionTags::from_slices(tag_names_slice, variable_slices);
let ext_var = TagExt::Any(Variable::EMPTY_TAG_UNION); let ext_var = TagExt::Any(Variable::EMPTY_TAG_UNION);
let flat_type = FlatType::TagUnion(union_tags, ext_var); let flat_type = FlatType::TagUnion(union_tags, ext_var);
let content = Content::Structure(flat_type); let content = Content::Structure(flat_type);
<<<<<<< HEAD
env.register(rank, content) env.register(rank, content)
=======
register(subs, rank, pools, content)
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
} }
/// Build an alias of the form `Num range := range` /// Build an alias of the form `Num range := range`
fn build_num_opaque( fn build_num_opaque(
<<<<<<< HEAD
env: &mut Env, env: &mut Env,
rank: Rank, rank: Rank,
=======
subs: &mut Subs,
rank: Rank,
pools: &mut Pools,
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
symbol: Symbol, symbol: Symbol,
range_var: Variable, range_var: Variable,
) -> Variable { ) -> Variable {
let content = Content::Alias( let content = Content::Alias(
symbol, symbol,
<<<<<<< HEAD
AliasVariables::insert_into_subs(env.subs, [range_var], [], []), AliasVariables::insert_into_subs(env.subs, [range_var], [], []),
=======
AliasVariables::insert_into_subs(subs, [range_var], [], []),
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
range_var, range_var,
AliasKind::Opaque, AliasKind::Opaque,
); );
<<<<<<< HEAD
env.register(rank, content) env.register(rank, content)
=======
register(subs, rank, pools, content)
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
} }
fn instantiate_builtin_aliases_real_var( fn instantiate_builtin_aliases_real_var(
&mut self, &mut self,
<<<<<<< HEAD
env: &mut Env, env: &mut Env,
rank: Rank, rank: Rank,
=======
subs: &mut Subs,
rank: Rank,
pools: &mut Pools,
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
symbol: Symbol, symbol: Symbol,
alias_variables: AliasVariables, alias_variables: AliasVariables,
) -> Option<(Variable, AliasKind)> { ) -> Option<(Variable, AliasKind)> {
match symbol { match symbol {
Symbol::RESULT_RESULT => { Symbol::RESULT_RESULT => {
<<<<<<< HEAD
let var = Self::instantiate_result_result(env, rank, alias_variables); let var = Self::instantiate_result_result(env, rank, alias_variables);
=======
let var = Self::instantiate_result_result(subs, rank, pools, alias_variables);
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
Some((var, AliasKind::Structural)) Some((var, AliasKind::Structural))
} }
Symbol::NUM_NUM | Symbol::NUM_INTEGER | Symbol::NUM_FLOATINGPOINT => { Symbol::NUM_NUM | Symbol::NUM_INTEGER | Symbol::NUM_FLOATINGPOINT => {
// Num range := range | Integer range := range | FloatingPoint range := range // Num range := range | Integer range := range | FloatingPoint range := range
<<<<<<< HEAD
let range_var = env.subs.variables[alias_variables.variables_start as usize]; let range_var = env.subs.variables[alias_variables.variables_start as usize];
=======
let range_var = subs.variables[alias_variables.variables_start as usize];
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
Some((range_var, AliasKind::Opaque)) Some((range_var, AliasKind::Opaque))
} }
Symbol::NUM_INT => { Symbol::NUM_INT => {
@ -223,27 +181,15 @@ impl Aliases {
// //
// build `Integer range := range` // build `Integer range := range`
let integer_content_var = Self::build_num_opaque( let integer_content_var = Self::build_num_opaque(
<<<<<<< HEAD
env, env,
rank, rank,
Symbol::NUM_INTEGER, Symbol::NUM_INTEGER,
env.subs.variables[alias_variables.variables_start as usize], env.subs.variables[alias_variables.variables_start as usize],
=======
subs,
rank,
pools,
Symbol::NUM_INTEGER,
subs.variables[alias_variables.variables_start as usize],
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
); );
// build `Num (Integer range) := Integer range` // build `Num (Integer range) := Integer range`
let num_content_var = let num_content_var =
<<<<<<< HEAD
Self::build_num_opaque(env, rank, Symbol::NUM_NUM, integer_content_var); Self::build_num_opaque(env, rank, Symbol::NUM_NUM, integer_content_var);
=======
Self::build_num_opaque(subs, rank, pools, Symbol::NUM_NUM, integer_content_var);
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
Some((num_content_var, AliasKind::Structural)) Some((num_content_var, AliasKind::Structural))
} }
@ -252,27 +198,15 @@ impl Aliases {
// //
// build `FloatingPoint range := range` // build `FloatingPoint range := range`
let fpoint_content_var = Self::build_num_opaque( let fpoint_content_var = Self::build_num_opaque(
<<<<<<< HEAD
env, env,
rank, rank,
Symbol::NUM_FLOATINGPOINT, Symbol::NUM_FLOATINGPOINT,
env.subs.variables[alias_variables.variables_start as usize], env.subs.variables[alias_variables.variables_start as usize],
=======
subs,
rank,
pools,
Symbol::NUM_FLOATINGPOINT,
subs.variables[alias_variables.variables_start as usize],
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
); );
// build `Num (FloatingPoint range) := FloatingPoint range` // build `Num (FloatingPoint range) := FloatingPoint range`
let num_content_var = let num_content_var =
<<<<<<< HEAD
Self::build_num_opaque(env, rank, Symbol::NUM_NUM, fpoint_content_var); Self::build_num_opaque(env, rank, Symbol::NUM_NUM, fpoint_content_var);
=======
Self::build_num_opaque(subs, rank, pools, Symbol::NUM_NUM, fpoint_content_var);
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
Some((num_content_var, AliasKind::Structural)) Some((num_content_var, AliasKind::Structural))
} }
@ -294,14 +228,8 @@ impl Aliases {
pub fn instantiate_real_var( pub fn instantiate_real_var(
&mut self, &mut self,
<<<<<<< HEAD
env: &mut Env, env: &mut Env,
rank: Rank, rank: Rank,
=======
subs: &mut Subs,
rank: Rank,
pools: &mut Pools,
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
problems: &mut Vec<TypeError>, problems: &mut Vec<TypeError>,
abilities_store: &AbilitiesStore, abilities_store: &AbilitiesStore,
obligation_cache: &mut ObligationCache, obligation_cache: &mut ObligationCache,
@ -311,20 +239,9 @@ impl Aliases {
alias_variables: AliasVariables, alias_variables: AliasVariables,
) -> (Variable, AliasKind) { ) -> (Variable, AliasKind) {
// hardcoded instantiations for builtin aliases // hardcoded instantiations for builtin aliases
<<<<<<< HEAD
if let Some((var, kind)) = if let Some((var, kind)) =
self.instantiate_builtin_aliases_real_var(env, rank, symbol, alias_variables) self.instantiate_builtin_aliases_real_var(env, rank, symbol, alias_variables)
{ {
=======
if let Some((var, kind)) = Self::instantiate_builtin_aliases_real_var(
self,
subs,
rank,
pools,
symbol,
alias_variables,
) {
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
return (var, kind); return (var, kind);
} }
@ -341,11 +258,7 @@ impl Aliases {
let mut substitutions: MutMap<_, _> = Default::default(); let mut substitutions: MutMap<_, _> = Default::default();
let old_type_variables = delayed_variables.type_variables(&mut self.variables); let old_type_variables = delayed_variables.type_variables(&mut self.variables);
<<<<<<< HEAD
let new_type_variables = &env.subs.variables[alias_variables.type_variables().indices()]; let new_type_variables = &env.subs.variables[alias_variables.type_variables().indices()];
=======
let new_type_variables = &subs.variables[alias_variables.type_variables().indices()];
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
for (old, new) in old_type_variables.iter_mut().zip(new_type_variables) { for (old, new) in old_type_variables.iter_mut().zip(new_type_variables) {
// if constraint gen duplicated a type these variables could be the same // if constraint gen duplicated a type these variables could be the same
@ -363,21 +276,13 @@ impl Aliases {
.iter_mut() .iter_mut()
{ {
debug_assert!(opt_abilities.is_none()); debug_assert!(opt_abilities.is_none());
<<<<<<< HEAD
let new_var = env.subs.fresh_unnamed_flex_var(); let new_var = env.subs.fresh_unnamed_flex_var();
=======
let new_var = subs.fresh_unnamed_flex_var();
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
substitutions.insert(*rec_var, new_var); substitutions.insert(*rec_var, new_var);
} }
let old_lambda_set_variables = delayed_variables.lambda_set_variables(&mut self.variables); let old_lambda_set_variables = delayed_variables.lambda_set_variables(&mut self.variables);
let new_lambda_set_variables = let new_lambda_set_variables =
<<<<<<< HEAD
&env.subs.variables[alias_variables.lambda_set_variables().indices()]; &env.subs.variables[alias_variables.lambda_set_variables().indices()];
=======
&subs.variables[alias_variables.lambda_set_variables().indices()];
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
for (old, new) in old_lambda_set_variables for (old, new) in old_lambda_set_variables
.iter_mut() .iter_mut()
@ -392,11 +297,7 @@ impl Aliases {
let old_infer_ext_vars = let old_infer_ext_vars =
delayed_variables.infer_ext_in_output_variables(&mut self.variables); delayed_variables.infer_ext_in_output_variables(&mut self.variables);
let new_infer_ext_vars = let new_infer_ext_vars =
<<<<<<< HEAD
&env.subs.variables[alias_variables.infer_ext_in_output_variables().indices()]; &env.subs.variables[alias_variables.infer_ext_in_output_variables().indices()];
=======
&subs.variables[alias_variables.infer_ext_in_output_variables().indices()];
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
for (old, new) in old_infer_ext_vars.iter_mut().zip(new_infer_ext_vars) { for (old, new) in old_infer_ext_vars.iter_mut().zip(new_infer_ext_vars) {
debug_assert!(old.opt_abilities.is_none()); debug_assert!(old.opt_abilities.is_none());
@ -412,14 +313,8 @@ impl Aliases {
}; };
let alias_variable = type_to_var_help( let alias_variable = type_to_var_help(
<<<<<<< HEAD
env, env,
rank, rank,
=======
subs,
rank,
pools,
>>>>>>> 6fa4cd24e (Break up solve/solve into smaller modules)
problems, problems,
abilities_store, abilities_store,
obligation_cache, obligation_cache,

40
crates/compiler/solve/src/solve.rs
View file

@ -484,7 +484,11 @@ fn solve(
); );
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
expected, expected,
Mode::EQ, Mode::EQ,
@ -591,7 +595,11 @@ fn solve(
); );
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
expected, expected,
Mode::EQ, Mode::EQ,
@ -698,7 +706,11 @@ fn solve(
}; };
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
expected, expected,
mode, mode,
@ -910,7 +922,11 @@ fn solve(
); );
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
includes, includes,
Mode::PRESENT, Mode::PRESENT,
@ -1044,7 +1060,11 @@ fn solve(
let snapshot = env.subs.snapshot(); let snapshot = env.subs.snapshot();
let unify_cond_and_patterns_outcome = unify( let unify_cond_and_patterns_outcome = unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
branches_var, branches_var,
real_var, real_var,
Mode::EQ, Mode::EQ,
@ -1094,7 +1114,11 @@ fn solve(
open_tag_union(env, branches_var); open_tag_union(env, branches_var);
let almost_eq = matches!( let almost_eq = matches!(
unify( unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
real_var, real_var,
branches_var, branches_var,
Mode::EQ, Mode::EQ,
@ -1112,7 +1136,11 @@ fn solve(
// Case 4: incompatible types, report type error. // Case 4: incompatible types, report type error.
// Re-run first failed unification to get the type diff. // Re-run first failed unification to get the type diff.
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
real_var, real_var,
branches_var, branches_var,
Mode::EQ, Mode::EQ,
@ -1311,7 +1339,11 @@ fn solve(
lambda_sets_to_specialize, lambda_sets_to_specialize,
extra_metadata: _, extra_metadata: _,
} = unify( } = unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
Variable::LIST_U8, Variable::LIST_U8,
Mode::EQ, Mode::EQ,
@ -1331,7 +1363,11 @@ fn solve(
// We explicitly match on the last unify to get the type in the case it errors. // We explicitly match on the last unify to get the type in the case it errors.
match unify( match unify(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
actual, actual,
Variable::STR, Variable::STR,
Mode::EQ, Mode::EQ,
@ -1574,7 +1610,11 @@ fn check_ability_specialization(
deep_copy_var_in(env, Rank::toplevel(), root_signature_var, env.arena); deep_copy_var_in(env, Rank::toplevel(), root_signature_var, env.arena);
let snapshot = env.subs.snapshot(); let snapshot = env.subs.snapshot();
let unified = unify_introduced_ability_specialization( let unified = unify_introduced_ability_specialization(
<<<<<<< HEAD
&mut env.uenv(), &mut env.uenv(),
=======
&mut UEnv::new(env.subs),
>>>>>>> e28273793 (Shove more into a common env)
root_signature_var, root_signature_var,
symbol_loc_var.value, symbol_loc_var.value,
Mode::EQ, Mode::EQ,