diff --git a/compiler/solve/src/module.rs b/compiler/solve/src/module.rs index 64b3c654c2..d121431c20 100644 --- a/compiler/solve/src/module.rs +++ b/compiler/solve/src/module.rs @@ -3,7 +3,7 @@ use roc_can::constraint::{Constraint as ConstraintSoa, Constraints}; use roc_can::module::RigidVariables; use roc_collections::all::MutMap; use roc_module::symbol::Symbol; -use roc_types::solved_types::{Solved, SolvedType}; +use roc_types::solved_types::Solved; use roc_types::subs::{StorageSubs, Subs, Variable}; use roc_types::types::Alias; @@ -60,26 +60,6 @@ pub fn run_solve( (solved_subs, solved_env, problems) } -pub fn make_solved_types( - solved_subs: &Solved, - exposed_vars_by_symbol: &[(Symbol, Variable)], -) -> MutMap { - let mut solved_types = MutMap::default(); - - // exposed_vars_by_symbol contains the Variables for all the Symbols - // this module exposes. We want to convert those into flat SolvedType - // annotations which are decoupled from our Subs, because that's how - // other modules will generate constraints for imported values - // within the context of their own Subs. - for (symbol, var) in exposed_vars_by_symbol.iter() { - let solved_type = SolvedType::new(solved_subs, *var); - - solved_types.insert(*symbol, solved_type); - } - - solved_types -} - pub fn exposed_types_storage_subs( solved_subs: &mut Solved, exposed_vars_by_symbol: &[(Symbol, Variable)], diff --git a/compiler/types/src/solved_types.rs b/compiler/types/src/solved_types.rs index 6516dace02..a9acc39cfa 100644 --- a/compiler/types/src/solved_types.rs +++ b/compiler/types/src/solved_types.rs @@ -1,6 +1,6 @@ -use crate::subs::{FlatType, GetSubsSlice, Subs, VarId, VarStore, Variable}; -use crate::types::{AliasCommon, AliasKind, Problem, RecordField, Type, TypeExtension}; -use roc_collections::all::{ImMap, MutSet, SendMap}; +use crate::subs::{VarId, VarStore, Variable}; +use crate::types::{AliasKind, Problem, RecordField, Type, TypeExtension}; +use roc_collections::all::{ImMap, SendMap}; use roc_module::ident::{Lowercase, TagName}; use roc_module::symbol::Symbol; use roc_region::all::{Loc, Region}; @@ -53,10 +53,6 @@ pub enum SolvedType { /// A type from an Invalid module Erroneous(Problem), - /// A type alias - /// TODO transmit lambda sets! - DelayedAlias(Symbol, Vec<(Lowercase, SolvedType)>, Vec), - Alias( Symbol, Vec<(Lowercase, SolvedType)>, @@ -77,378 +73,6 @@ pub enum SolvedType { Error, } -impl SolvedType { - pub fn new(solved_subs: &Solved, var: Variable) -> Self { - Self::from_var(solved_subs.inner(), var) - } - - pub fn from_type(solved_subs: &Solved, typ: &Type) -> Self { - use crate::types::Type::*; - - match typ { - EmptyRec => SolvedType::EmptyRecord, - EmptyTagUnion => SolvedType::EmptyTagUnion, - Apply(symbol, types, _) => { - let mut solved_types = Vec::with_capacity(types.len()); - - for typ in types { - let solved_type = Self::from_type(solved_subs, typ); - - solved_types.push(solved_type); - } - - SolvedType::Apply(*symbol, solved_types) - } - Function(args, box_closure, box_ret) => { - let solved_ret = Self::from_type(solved_subs, box_ret); - let solved_closure = Self::from_type(solved_subs, box_closure); - let mut solved_args = Vec::with_capacity(args.len()); - - for arg in args { - let solved_arg = Self::from_type(solved_subs, arg); - - solved_args.push(solved_arg); - } - - SolvedType::Func(solved_args, Box::new(solved_closure), Box::new(solved_ret)) - } - Record(fields, box_ext) => { - let solved_ext = match box_ext { - TypeExtension::Open(ext) => Self::from_type(solved_subs, ext), - TypeExtension::Closed => SolvedType::EmptyRecord, - }; - - let mut solved_fields = Vec::with_capacity(fields.len()); - - for (label, field) in fields { - use crate::types::RecordField::*; - - let solved_type = match field { - Optional(typ) => RecordField::Optional(Self::from_type(solved_subs, typ)), - Required(typ) => RecordField::Required(Self::from_type(solved_subs, typ)), - Demanded(typ) => RecordField::Demanded(Self::from_type(solved_subs, typ)), - }; - - solved_fields.push((label.clone(), solved_type)); - } - - SolvedType::Record { - fields: solved_fields, - ext: Box::new(solved_ext), - } - } - ClosureTag { name, ext } => { - let solved_ext = Self::from_type(solved_subs, &Type::Variable(*ext)); - let solved_tags = vec![(TagName::Closure(*name), vec![])]; - SolvedType::TagUnion(solved_tags, Box::new(solved_ext)) - } - TagUnion(tags, box_ext) => { - let solved_ext = match box_ext { - TypeExtension::Open(ext) => Self::from_type(solved_subs, ext), - TypeExtension::Closed => SolvedType::EmptyTagUnion, - }; - - let mut solved_tags = Vec::with_capacity(tags.len()); - for (tag_name, types) in tags { - let mut solved_types = Vec::with_capacity(types.len()); - - for typ in types { - let solved_type = Self::from_type(solved_subs, typ); - solved_types.push(solved_type); - } - - solved_tags.push((tag_name.clone(), solved_types)); - } - - SolvedType::TagUnion(solved_tags, Box::new(solved_ext)) - } - FunctionOrTagUnion(tag_name, symbol, box_ext) => { - let solved_ext = match box_ext { - TypeExtension::Open(ext) => Self::from_type(solved_subs, ext), - TypeExtension::Closed => SolvedType::EmptyTagUnion, - }; - - SolvedType::FunctionOrTagUnion(tag_name.clone(), *symbol, Box::new(solved_ext)) - } - RecursiveTagUnion(rec_var, tags, box_ext) => { - let solved_ext = match box_ext { - TypeExtension::Open(ext) => Self::from_type(solved_subs, ext), - TypeExtension::Closed => SolvedType::EmptyTagUnion, - }; - - let mut solved_tags = Vec::with_capacity(tags.len()); - for (tag_name, types) in tags { - let mut solved_types = Vec::with_capacity(types.len()); - - for typ in types { - let solved_type = Self::from_type(solved_subs, typ); - solved_types.push(solved_type); - } - - solved_tags.push((tag_name.clone(), solved_types)); - } - - SolvedType::RecursiveTagUnion( - VarId::from_var(*rec_var, solved_subs.inner()), - solved_tags, - Box::new(solved_ext), - ) - } - Erroneous(problem) => SolvedType::Erroneous(problem.clone()), - DelayedAlias(AliasCommon { - symbol, - type_arguments, - lambda_set_variables, - }) => { - let mut solved_args = Vec::with_capacity(type_arguments.len()); - - for (name, var) in type_arguments { - solved_args.push((name.clone(), Self::from_type(solved_subs, var))); - } - - let mut solved_lambda_sets = Vec::with_capacity(lambda_set_variables.len()); - - for var in lambda_set_variables { - solved_lambda_sets.push(SolvedLambdaSet(Self::from_type(solved_subs, &var.0))); - } - - SolvedType::DelayedAlias(*symbol, solved_args, solved_lambda_sets) - } - Alias { - symbol, - type_arguments, - lambda_set_variables, - actual: box_type, - kind, - } => { - let solved_type = Self::from_type(solved_subs, box_type); - let mut solved_args = Vec::with_capacity(type_arguments.len()); - - for (name, var) in type_arguments { - solved_args.push((name.clone(), Self::from_type(solved_subs, var))); - } - - let mut solved_lambda_sets = Vec::with_capacity(lambda_set_variables.len()); - - for var in lambda_set_variables { - solved_lambda_sets.push(SolvedLambdaSet(Self::from_type(solved_subs, &var.0))); - } - - SolvedType::Alias( - *symbol, - solved_args, - solved_lambda_sets, - Box::new(solved_type), - *kind, - ) - } - HostExposedAlias { - name, - type_arguments: arguments, - lambda_set_variables, - actual_var, - actual, - } => { - let solved_type = Self::from_type(solved_subs, actual); - let mut solved_args = Vec::with_capacity(arguments.len()); - - for (name, var) in arguments { - solved_args.push((name.clone(), Self::from_type(solved_subs, var))); - } - - let mut solved_lambda_sets = Vec::with_capacity(lambda_set_variables.len()); - for var in lambda_set_variables { - solved_lambda_sets.push(SolvedLambdaSet(Self::from_type(solved_subs, &var.0))); - } - - SolvedType::HostExposedAlias { - name: *name, - arguments: solved_args, - lambda_set_variables: solved_lambda_sets, - actual_var: VarId::from_var(*actual_var, solved_subs.inner()), - actual: Box::new(solved_type), - } - } - Variable(var) => Self::from_var(solved_subs.inner(), *var), - RangedNumber(typ, _) => Self::from_type(solved_subs, typ), - } - } - - fn from_var(subs: &Subs, var: Variable) -> Self { - let mut seen = RecursionVars::default(); - Self::from_var_help(subs, &mut seen, var) - } - - fn from_var_help(subs: &Subs, recursion_vars: &mut RecursionVars, var: Variable) -> Self { - use crate::subs::Content::*; - - // if this is a recursion var we've seen before, just generate a Flex - // (not doing so would have this function loop forever) - if recursion_vars.contains(subs, var) { - return SolvedType::Flex(VarId::from_var(var, subs)); - } - - match subs.get_content_without_compacting(var) { - FlexVar(_) => SolvedType::Flex(VarId::from_var(var, subs)), - RecursionVar { structure, .. } => { - // TODO should there be a SolvedType RecursionVar variant? - Self::from_var_help(subs, recursion_vars, *structure) - } - RigidVar(name_index) => { - let name = &subs.field_names[name_index.index as usize]; - SolvedType::Rigid(name.clone()) - } - Structure(flat_type) => Self::from_flat_type(subs, recursion_vars, flat_type), - Alias(symbol, args, actual_var, kind) => { - let mut new_args = Vec::with_capacity(args.len()); - - for var_index in args.named_type_arguments() { - let arg_var = subs[var_index]; - - let node = Self::from_var_help(subs, recursion_vars, arg_var); - - // NOTE we fake the lowercase here: the user will never get to see it anyway - new_args.push((Lowercase::default(), node)); - } - - let mut solved_lambda_sets = Vec::with_capacity(0); - - for var_index in args.unnamed_type_arguments() { - let var = subs[var_index]; - - solved_lambda_sets.push(SolvedLambdaSet(Self::from_var_help( - subs, - recursion_vars, - var, - ))); - } - - let aliased_to = Self::from_var_help(subs, recursion_vars, *actual_var); - - SolvedType::Alias( - *symbol, - new_args, - solved_lambda_sets, - Box::new(aliased_to), - *kind, - ) - } - RangedNumber(typ, _range_vars) => Self::from_var_help(subs, recursion_vars, *typ), - Error => SolvedType::Error, - } - } - - fn from_flat_type( - subs: &Subs, - recursion_vars: &mut RecursionVars, - flat_type: &FlatType, - ) -> Self { - use crate::subs::FlatType::*; - - match flat_type { - Apply(symbol, args) => { - let mut new_args = Vec::with_capacity(args.len()); - - for var in subs.get_subs_slice(*args) { - new_args.push(Self::from_var_help(subs, recursion_vars, *var)); - } - - SolvedType::Apply(*symbol, new_args) - } - Func(args, closure, ret) => { - let mut new_args = Vec::with_capacity(args.len()); - - for var in subs.get_subs_slice(*args) { - new_args.push(Self::from_var_help(subs, recursion_vars, *var)); - } - - let ret = Self::from_var_help(subs, recursion_vars, *ret); - let closure = Self::from_var_help(subs, recursion_vars, *closure); - - SolvedType::Func(new_args, Box::new(closure), Box::new(ret)) - } - Record(fields, ext_var) => { - let mut new_fields = Vec::with_capacity(fields.len()); - - for (i1, i2, i3) in fields.iter_all() { - let field_name: Lowercase = subs[i1].clone(); - let variable: Variable = subs[i2]; - let record_field: RecordField<()> = subs[i3]; - - let solved_type = - record_field.map(|_| Self::from_var_help(subs, recursion_vars, variable)); - - new_fields.push((field_name, solved_type)); - } - - let ext = Self::from_var_help(subs, recursion_vars, *ext_var); - - SolvedType::Record { - fields: new_fields, - ext: Box::new(ext), - } - } - TagUnion(tags, ext_var) => { - let mut new_tags = Vec::with_capacity(tags.len()); - - for (name_index, slice_index) in tags.iter_all() { - let slice = subs[slice_index]; - - let mut new_args = Vec::with_capacity(slice.len()); - - for var_index in slice { - let var = subs[var_index]; - new_args.push(Self::from_var_help(subs, recursion_vars, var)); - } - let tag_name = subs[name_index].clone(); - new_tags.push((tag_name.clone(), new_args)); - } - - let ext = Self::from_var_help(subs, recursion_vars, *ext_var); - - SolvedType::TagUnion(new_tags, Box::new(ext)) - } - FunctionOrTagUnion(tag_name, symbol, ext_var) => { - let ext = Self::from_var_help(subs, recursion_vars, *ext_var); - - SolvedType::FunctionOrTagUnion(subs[*tag_name].clone(), *symbol, Box::new(ext)) - } - RecursiveTagUnion(rec_var, tags, ext_var) => { - recursion_vars.insert(subs, *rec_var); - - let mut new_tags = Vec::with_capacity(tags.len()); - - for (name_index, slice_index) in tags.iter_all() { - let slice = subs[slice_index]; - - let mut new_args = Vec::with_capacity(slice.len()); - - for var_index in slice { - let var = subs[var_index]; - new_args.push(Self::from_var_help(subs, recursion_vars, var)); - } - let tag_name = subs[name_index].clone(); - new_tags.push((tag_name.clone(), new_args)); - } - - let ext = Self::from_var_help(subs, recursion_vars, *ext_var); - - SolvedType::RecursiveTagUnion( - VarId::from_var(*rec_var, subs), - new_tags, - Box::new(ext), - ) - } - EmptyRecord => SolvedType::EmptyRecord, - EmptyTagUnion => SolvedType::EmptyTagUnion, - Erroneous(problem_index) => { - let problem = subs.problems[problem_index.index as usize].clone(); - SolvedType::Erroneous(problem) - } - } - } -} - #[derive(Clone, Debug)] pub struct BuiltinAlias { pub region: Region, @@ -456,23 +80,6 @@ pub struct BuiltinAlias { pub typ: SolvedType, } -#[derive(Default)] -struct RecursionVars(MutSet); - -impl RecursionVars { - fn contains(&self, subs: &Subs, var: Variable) -> bool { - let var = subs.get_root_key_without_compacting(var); - - self.0.contains(&var) - } - - fn insert(&mut self, subs: &Subs, var: Variable) { - let var = subs.get_root_key_without_compacting(var); - - self.0.insert(var); - } -} - #[derive(Debug, Clone, Default)] pub struct FreeVars { pub named_vars: ImMap, @@ -601,28 +208,6 @@ pub fn to_type( Type::RecursiveTagUnion(*rec_var, new_tags, ext) } - DelayedAlias(symbol, solved_type_variables, solved_lambda_sets) => { - let mut type_variables = Vec::with_capacity(solved_type_variables.len()); - - for (lowercase, solved_arg) in solved_type_variables { - type_variables.push((lowercase.clone(), to_type(solved_arg, free_vars, var_store))); - } - - let mut lambda_set_variables = Vec::with_capacity(solved_lambda_sets.len()); - for solved_set in solved_lambda_sets { - lambda_set_variables.push(crate::types::LambdaSet(to_type( - &solved_set.0, - free_vars, - var_store, - ))) - } - - Type::DelayedAlias(AliasCommon { - symbol: *symbol, - type_arguments: type_variables, - lambda_set_variables, - }) - } Alias(symbol, solved_type_variables, solved_lambda_sets, solved_actual, kind) => { let mut type_variables = Vec::with_capacity(solved_type_variables.len());