diff --git a/crates/compiler/types/src/builtin_aliases.rs b/crates/ast/src/builtin_aliases.rs similarity index 91% rename from crates/compiler/types/src/builtin_aliases.rs rename to crates/ast/src/builtin_aliases.rs index 3002f85783..4bfdd472aa 100644 --- a/crates/compiler/types/src/builtin_aliases.rs +++ b/crates/ast/src/builtin_aliases.rs @@ -1,12 +1,76 @@ -use crate::solved_types::{BuiltinAlias, SolvedType}; -use crate::subs::VarId; -use crate::types::{AliasKind, RecordField}; -use roc_collections::all::{default_hasher, MutMap}; -use roc_module::ident::TagName; +use roc_collections::all::{default_hasher, ImMap, MutMap}; +use roc_module::ident::{Lowercase, TagName}; use roc_module::symbol::Symbol; use roc_region::all::{Loc, Region}; +use roc_types::subs::{VarId, Variable}; +use roc_types::types::{AliasKind, Problem, RecordField}; use std::collections::HashMap; +#[derive(Debug, Clone)] +pub struct SolvedLambdaSet(pub SolvedType); + +/// This is a fully solved type, with no Variables remaining in it. +#[derive(Debug, Clone)] +pub enum SolvedType { + /// A function. The types of its arguments, then the type of its return value. + Func(Vec, Box, Box), + /// Applying a type to some arguments (e.g. Map.Map String Int) + Apply(Symbol, Vec), + /// A bound type variable, e.g. `a` in `(a -> a)` + Rigid(Lowercase), + Flex(VarId), + Wildcard, + /// Inline type alias, e.g. `as List a` in `[Cons a (List a), Nil] as List a` + Record { + fields: Vec<(Lowercase, RecordField)>, + /// The row type variable in an open record, e.g. the `r` in `{ name: Str }r`. + /// This is None if it's a closed record annotation like `{ name: Str }`. + ext: Box, + }, + EmptyRecord, + TagUnion(Vec<(TagName, Vec)>, Box), + LambdaTag(Symbol, Vec), + FunctionOrTagUnion(TagName, Symbol, Box), + RecursiveTagUnion(VarId, Vec<(TagName, Vec)>, Box), + EmptyTagUnion, + /// A type from an Invalid module + Erroneous(Problem), + + Alias( + Symbol, + Vec, + Vec, + Box, + AliasKind, + ), + + HostExposedAlias { + name: Symbol, + arguments: Vec, + lambda_set_variables: Vec, + actual_var: VarId, + actual: Box, + }, + + /// A type error + Error, +} + +#[derive(Clone, Debug)] +pub struct BuiltinAlias { + pub region: Region, + pub vars: Vec>, + pub typ: SolvedType, + pub kind: AliasKind, +} + +#[derive(Debug, Clone, Default)] +pub struct FreeVars { + pub named_vars: ImMap, + pub unnamed_vars: ImMap, + pub wildcards: Vec, +} + const NUM_BUILTIN_IMPORTS: usize = 8; /// These can be shared between definitions, they will get instantiated when converted to Type diff --git a/crates/ast/src/lang/scope.rs b/crates/ast/src/lang/scope.rs index c8e203da4c..7490df6fe1 100644 --- a/crates/ast/src/lang/scope.rs +++ b/crates/ast/src/lang/scope.rs @@ -5,6 +5,7 @@ use std::fmt; use crate::ast_error::ASTResult; +use crate::builtin_aliases::{self, BuiltinAlias, FreeVars, SolvedType}; use crate::mem_pool::pool::Pool; use crate::mem_pool::pool_str::PoolStr; use crate::mem_pool::pool_vec::PoolVec; @@ -17,11 +18,7 @@ use roc_module::symbol::{ }; use roc_problem::can::RuntimeError; use roc_region::all::{Loc, Region}; -use roc_types::{ - builtin_aliases, - solved_types::{BuiltinAlias, FreeVars, SolvedType}, - subs::{VarId, VarStore, Variable}, -}; +use roc_types::subs::{VarId, VarStore, Variable}; use super::core::types::{Alias, Type2, TypeId}; use super::env::Env; diff --git a/crates/ast/src/lib.rs b/crates/ast/src/lib.rs index 092b86154e..610ed3442b 100644 --- a/crates/ast/src/lib.rs +++ b/crates/ast/src/lib.rs @@ -1,4 +1,5 @@ pub mod ast_error; +mod builtin_aliases; mod canonicalization; pub mod constrain; pub mod lang; diff --git a/crates/compiler/types/src/lib.rs b/crates/compiler/types/src/lib.rs index 0846e058aa..09e98b7d82 100644 --- a/crates/compiler/types/src/lib.rs +++ b/crates/compiler/types/src/lib.rs @@ -1,10 +1,8 @@ #![warn(clippy::dbg_macro)] // See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. #![allow(clippy::large_enum_variant)] -pub mod builtin_aliases; pub mod num; pub mod pretty_print; -pub mod solved_types; pub mod subs; pub mod types; mod unification_table; diff --git a/crates/compiler/types/src/solved_types.rs b/crates/compiler/types/src/solved_types.rs deleted file mode 100644 index 8e9a68baeb..0000000000 --- a/crates/compiler/types/src/solved_types.rs +++ /dev/null @@ -1,71 +0,0 @@ -use crate::subs::{VarId, Variable}; -use crate::types::{AliasKind, Problem, RecordField}; -use roc_collections::all::ImMap; -use roc_module::ident::{Lowercase, TagName}; -use roc_module::symbol::Symbol; -use roc_region::all::{Loc, Region}; - -#[derive(Debug, Clone)] -pub struct SolvedLambdaSet(pub SolvedType); - -/// This is a fully solved type, with no Variables remaining in it. -#[derive(Debug, Clone)] -pub enum SolvedType { - /// A function. The types of its arguments, then the type of its return value. - Func(Vec, Box, Box), - /// Applying a type to some arguments (e.g. Map.Map String Int) - Apply(Symbol, Vec), - /// A bound type variable, e.g. `a` in `(a -> a)` - Rigid(Lowercase), - Flex(VarId), - Wildcard, - /// Inline type alias, e.g. `as List a` in `[Cons a (List a), Nil] as List a` - Record { - fields: Vec<(Lowercase, RecordField)>, - /// The row type variable in an open record, e.g. the `r` in `{ name: Str }r`. - /// This is None if it's a closed record annotation like `{ name: Str }`. - ext: Box, - }, - EmptyRecord, - TagUnion(Vec<(TagName, Vec)>, Box), - LambdaTag(Symbol, Vec), - FunctionOrTagUnion(TagName, Symbol, Box), - RecursiveTagUnion(VarId, Vec<(TagName, Vec)>, Box), - EmptyTagUnion, - /// A type from an Invalid module - Erroneous(Problem), - - Alias( - Symbol, - Vec, - Vec, - Box, - AliasKind, - ), - - HostExposedAlias { - name: Symbol, - arguments: Vec, - lambda_set_variables: Vec, - actual_var: VarId, - actual: Box, - }, - - /// A type error - Error, -} - -#[derive(Clone, Debug)] -pub struct BuiltinAlias { - pub region: Region, - pub vars: Vec>, - pub typ: SolvedType, - pub kind: AliasKind, -} - -#[derive(Debug, Clone, Default)] -pub struct FreeVars { - pub named_vars: ImMap, - pub unnamed_vars: ImMap, - pub wildcards: Vec, -}