language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 14:54:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge pull request #2065 from rtfeldman/alias-remove-lowercases

Browse source 
Alias remove lowercases
This commit is contained in:
Folkert de Vries 2021-11-23 10:21:05 +01:00 • committed by GitHub
commit 6944c900c2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 75 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ast/src/solve_type.rs
View file

@ -810,17 +810,13 @@ fn type_to_variable<'a>(
*/ */
let mut arg_vars = Vec::with_capacity(args.len()); let mut arg_vars = Vec::with_capacity(args.len());
let mut new_aliases = BumpMap::new_in(arena);
for (arg, arg_type_id) in args.iter(mempool) { for (_, arg_type_id) in args.iter(mempool) {
let arg_type = mempool.get(*arg_type_id); let arg_type = mempool.get(*arg_type_id);
let arg_var = type_to_variable(arena, mempool, subs, rank, pools, cached, arg_type); let arg_var = type_to_variable(arena, mempool, subs, rank, pools, cached, arg_type);
let arg_str = arg.as_str(mempool); arg_vars.push(arg_var);
arg_vars.push((roc_module::ident::Lowercase::from(arg_str), arg_var));
new_aliases.insert(arg_str, arg_var);
} }
let arg_vars = AliasVariables::insert_into_subs(subs, arg_vars, []); let arg_vars = AliasVariables::insert_into_subs(subs, arg_vars, []);

2
compiler/module/src/ident.rs
View file

@ -29,7 +29,7 @@ impl std::ops::Deref for ModuleName {
} }
/// An uncapitalized identifier, such as a field name or local variable /// An uncapitalized identifier, such as a field name or local variable
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] #[derive(Clone, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Lowercase(IdentStr); pub struct Lowercase(IdentStr);
/// A capitalized identifier, such as a tag name or module name /// A capitalized identifier, such as a tag name or module name

8
compiler/solve/src/solve.rs
View file

@ -788,10 +788,10 @@ fn type_to_variable<'a>(
let mut arg_vars = Vec::with_capacity_in(args.len(), arena); let mut arg_vars = Vec::with_capacity_in(args.len(), arena);
for (arg, arg_type) in args { for (_, arg_type) in args {
let arg_var = type_to_variable(subs, rank, pools, arena, arg_type); let arg_var = type_to_variable(subs, rank, pools, arena, arg_type);
arg_vars.push((arg.clone(), arg_var)); arg_vars.push(arg_var);
} }
let lambda_set_variables_it = lambda_set_variables let lambda_set_variables_it = lambda_set_variables
@ -816,10 +816,10 @@ fn type_to_variable<'a>(
} => { } => {
let mut arg_vars = Vec::with_capacity_in(args.len(), arena); let mut arg_vars = Vec::with_capacity_in(args.len(), arena);
for (arg, arg_type) in args { for (_, arg_type) in args {
let arg_var = type_to_variable(subs, rank, pools, arena, arg_type); let arg_var = type_to_variable(subs, rank, pools, arena, arg_type);
arg_vars.push((arg.clone(), arg_var)); arg_vars.push(arg_var);
} }
let lambda_set_variables_it = lambda_set_variables let lambda_set_variables_it = lambda_set_variables

5
compiler/types/src/pretty_print.rs
View file

@ -199,7 +199,7 @@ fn find_names_needed(
} }
Alias(_symbol, args, _actual) => { Alias(_symbol, args, _actual) => {
// only find names for named parameters! // only find names for named parameters!
for var_index in args.variables().into_iter().take(args.len()) { for var_index in args.into_iter().take(args.len()) {
let var = subs[var_index]; let var = subs[var_index];
find_names_needed(var, subs, roots, root_appearances, names_taken); find_names_needed(var, subs, roots, root_appearances, names_taken);
} }
@ -309,7 +309,6 @@ fn write_content(env: &Env, content: &Content, subs: &Subs, buf: &mut String, pa
debug_assert_eq!(args.len(), 1); debug_assert_eq!(args.len(), 1);
let arg_var_index = args let arg_var_index = args
.variables()
.into_iter() .into_iter()
.next() .next()
.expect("Num was not applied to a type argument!"); .expect("Num was not applied to a type argument!");
@ -337,7 +336,7 @@ fn write_content(env: &Env, content: &Content, subs: &Subs, buf: &mut String, pa
_ => write_parens!(write_parens, buf, { _ => write_parens!(write_parens, buf, {
write_symbol(env, *symbol, buf); write_symbol(env, *symbol, buf);
for var_index in args.variables() { for var_index in args.into_iter() {
let var = subs[var_index]; let var = subs[var_index];
buf.push(' '); buf.push(' ');
write_content( write_content(

13
compiler/types/src/solved_types.rs
View file

@ -229,7 +229,7 @@ impl SolvedType {
} }
} }
pub fn from_var(subs: &Subs, var: Variable) -> Self { fn from_var(subs: &Subs, var: Variable) -> Self {
let mut seen = RecursionVars::default(); let mut seen = RecursionVars::default();
Self::from_var_help(subs, &mut seen, var) Self::from_var_help(subs, &mut seen, var)
} }
@ -254,16 +254,17 @@ impl SolvedType {
Alias(symbol, args, actual_var) => { Alias(symbol, args, actual_var) => {
let mut new_args = Vec::with_capacity(args.len()); let mut new_args = Vec::with_capacity(args.len());
for (name_index, var_index) in args.named_type_arguments() { for var_index in args.named_type_arguments() {
let arg_var = subs[var_index]; let arg_var = subs[var_index];
new_args.push(( let node = Self::from_var_help(subs, recursion_vars, arg_var);
subs[name_index].clone(),
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); let mut solved_lambda_sets = Vec::with_capacity(0);
for var_index in args.unnamed_type_arguments() { for var_index in args.unnamed_type_arguments() {
let var = subs[var_index]; let var = subs[var_index];

104
compiler/types/src/subs.rs
View file

@ -797,7 +797,7 @@ fn integer_type(
Content::Structure(FlatType::TagUnion(tags, Variable::EMPTY_TAG_UNION)) Content::Structure(FlatType::TagUnion(tags, Variable::EMPTY_TAG_UNION))
}); });
let vars = AliasVariables::insert_into_subs(subs, [("range".into(), signed64)], []); let vars = AliasVariables::insert_into_subs(subs, [signed64], []);
subs.set_content(num_integer_signed64, { subs.set_content(num_integer_signed64, {
Content::Alias(Symbol::NUM_INTEGER, vars, at_signed64) Content::Alias(Symbol::NUM_INTEGER, vars, at_signed64)
}); });
@ -812,7 +812,7 @@ fn integer_type(
Content::Structure(FlatType::TagUnion(tags, Variable::EMPTY_TAG_UNION)) Content::Structure(FlatType::TagUnion(tags, Variable::EMPTY_TAG_UNION))
}); });
let vars = AliasVariables::insert_into_subs(subs, [("range".into(), integer_signed64)], []); let vars = AliasVariables::insert_into_subs(subs, [integer_signed64], []);
subs.set_content(num_integer_signed64, { subs.set_content(num_integer_signed64, {
Content::Alias(Symbol::NUM_NUM, vars, at_num_integer_signed64) Content::Alias(Symbol::NUM_NUM, vars, at_num_integer_signed64)
}); });
@ -1358,7 +1358,7 @@ impl From<Content> for Descriptor {
static_assertions::assert_eq_size!([u8; 4 * 8], Content); static_assertions::assert_eq_size!([u8; 4 * 8], Content);
static_assertions::assert_eq_size!([u8; 4 * 8], (Variable, Option<Lowercase>)); static_assertions::assert_eq_size!([u8; 4 * 8], (Variable, Option<Lowercase>));
static_assertions::assert_eq_size!([u8; 3 * 8], (Symbol, AliasVariables, Variable)); static_assertions::assert_eq_size!([u8; 3 * 8], (Symbol, AliasVariables, Variable));
static_assertions::assert_eq_size!([u8; 12], AliasVariables); static_assertions::assert_eq_size!([u8; 8], AliasVariables);
static_assertions::assert_eq_size!([u8; 3 * 8], FlatType); static_assertions::assert_eq_size!([u8; 3 * 8], FlatType);
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -1382,29 +1382,26 @@ pub enum Content {
#[derive(Clone, Copy, Debug, Default)] #[derive(Clone, Copy, Debug, Default)]
pub struct AliasVariables { pub struct AliasVariables {
pub lowercases_start: u32,
pub variables_start: u32, pub variables_start: u32,
pub lowercases_len: u16, pub all_variables_len: u16,
pub variables_len: u16,
/// an alias has type variables and lambda set variables
pub type_variables_len: u16,
} }
impl AliasVariables { impl AliasVariables {
pub const fn names(&self) -> SubsSlice<Lowercase> {
SubsSlice::new(self.lowercases_start, self.lowercases_len)
}
pub const fn variables(&self) -> VariableSubsSlice { pub const fn variables(&self) -> VariableSubsSlice {
VariableSubsSlice { VariableSubsSlice {
slice: SubsSlice::new(self.variables_start, self.variables_len), slice: SubsSlice::new(self.variables_start, self.all_variables_len),
} }
} }
pub const fn len(&self) -> usize { pub const fn len(&self) -> usize {
self.lowercases_len as usize self.type_variables_len as usize
} }
pub const fn is_empty(&self) -> bool { pub const fn is_empty(&self) -> bool {
self.lowercases_len == 0 self.type_variables_len == 0
} }
pub fn replace_variables( pub fn replace_variables(
@ -1416,24 +1413,21 @@ impl AliasVariables {
subs.variables.extend(variables); subs.variables.extend(variables);
let variables_len = (subs.variables.len() - variables_start as usize) as u16; let variables_len = (subs.variables.len() - variables_start as usize) as u16;
debug_assert_eq!(variables_len, self.variables_len); debug_assert_eq!(variables_len, self.all_variables_len);
self.variables_start = variables_start; self.variables_start = variables_start;
} }
pub fn named_type_arguments( pub fn named_type_arguments(&self) -> impl Iterator<Item = SubsIndex<Variable>> {
&self, self.variables()
) -> impl Iterator<Item = (SubsIndex<Lowercase>, SubsIndex<Variable>)> { .into_iter()
let names = self.names(); .take(self.type_variables_len as usize)
let vars = self.variables();
names.into_iter().zip(vars.into_iter())
} }
pub fn unnamed_type_arguments(&self) -> impl Iterator<Item = SubsIndex<Variable>> { pub fn unnamed_type_arguments(&self) -> impl Iterator<Item = SubsIndex<Variable>> {
self.variables() self.variables()
.into_iter() .into_iter()
.skip(self.lowercases_len as usize) .skip(self.type_variables_len as usize)
} }
pub fn insert_into_subs<I1, I2>( pub fn insert_into_subs<I1, I2>(
@ -1442,38 +1436,41 @@ impl AliasVariables {
unnamed_arguments: I2, unnamed_arguments: I2,
) -> Self ) -> Self
where where
I1: IntoIterator<Item = (Lowercase, Variable)>, I1: IntoIterator<Item = Variable>,
I2: IntoIterator<Item = Variable>, I2: IntoIterator<Item = Variable>,
{ {
let lowercases_start = subs.field_names.len() as u32;
let variables_start = subs.variables.len() as u32; let variables_start = subs.variables.len() as u32;
let it1 = type_arguments.into_iter(); subs.variables.extend(type_arguments);
let it2 = unnamed_arguments.into_iter();
subs.variables let type_variables_len = (subs.variables.len() as u32 - variables_start) as u16;
.reserve(it1.size_hint().0 + it2.size_hint().0);
subs.field_names.reserve(it1.size_hint().0);
for (field_name, var) in it1 { subs.variables.extend(unnamed_arguments);
subs.field_names.push(field_name);
subs.variables.push(var); let all_variables_len = (subs.variables.len() as u32 - variables_start) as u16;
if type_variables_len == 3 {
panic!();
} }
subs.variables.extend(it2);
let lowercases_len = (subs.field_names.len() as u32 - lowercases_start) as u16;
let variables_len = (subs.variables.len() as u32 - variables_start) as u16;
Self { Self {
lowercases_start,
variables_start, variables_start,
lowercases_len, type_variables_len,
variables_len, all_variables_len,
} }
} }
} }
impl IntoIterator for AliasVariables {
type Item = <VariableSubsSlice as IntoIterator>::Item;
type IntoIter = <VariableSubsSlice as IntoIterator>::IntoIter;
fn into_iter(self) -> Self::IntoIter {
self.variables().into_iter()
}
}
impl Content { impl Content {
#[inline(always)] #[inline(always)]
pub fn is_number(&self) -> bool { pub fn is_number(&self) -> bool {
@ -2090,7 +2087,7 @@ fn occurs(
let mut new_seen = seen.clone(); let mut new_seen = seen.clone();
new_seen.insert(root_var); new_seen.insert(root_var);
for var_index in args.variables().into_iter() { for var_index in args.into_iter() {
let var = subs[var_index]; let var = subs[var_index];
short_circuit_help(subs, root_var, &new_seen, var)?; short_circuit_help(subs, root_var, &new_seen, var)?;
} }
@ -2274,7 +2271,7 @@ fn explicit_substitute(
in_var in_var
} }
Alias(symbol, args, actual) => { Alias(symbol, args, actual) => {
for index in args.variables().into_iter() { for index in args.into_iter() {
let var = subs[index]; let var = subs[index];
let new_var = explicit_substitute(subs, from, to, var, seen); let new_var = explicit_substitute(subs, from, to, var, seen);
subs[index] = new_var; subs[index] = new_var;
@ -2331,10 +2328,7 @@ fn get_var_names(
RigidVar(name) => add_name(subs, 0, name, var, RigidVar, taken_names), RigidVar(name) => add_name(subs, 0, name, var, RigidVar, taken_names),
Alias(_, args, _) => args Alias(_, args, _) => args.into_iter().fold(taken_names, |answer, arg_var| {
.variables()
.into_iter()
.fold(taken_names, |answer, arg_var| {
get_var_names(subs, subs[arg_var], answer) get_var_names(subs, subs[arg_var], answer)
}), }),
@ -2537,15 +2531,14 @@ fn content_to_err_type(
Alias(symbol, args, aliased_to) => { Alias(symbol, args, aliased_to) => {
let err_type = var_to_err_type(subs, state, aliased_to); let err_type = var_to_err_type(subs, state, aliased_to);
let mut err_args = Vec::with_capacity(args.names().len()); let mut err_args = Vec::with_capacity(args.len());
for (name_index, var_index) in args.named_type_arguments() { for var_index in args.into_iter() {
let name = subs[name_index].clone();
let var = subs[var_index]; let var = subs[var_index];
let arg = var_to_err_type(subs, state, var); let arg = var_to_err_type(subs, state, var);
err_args.push((name, arg)); err_args.push(arg);
} }
ErrorType::Alias(symbol, err_args, Box::new(err_type)) ErrorType::Alias(symbol, err_args, Box::new(err_type))
@ -2998,7 +2991,6 @@ impl StorageSubs {
offsets: &StorageSubsOffsets, offsets: &StorageSubsOffsets,
mut alias_variables: AliasVariables, mut alias_variables: AliasVariables,
) -> AliasVariables { ) -> AliasVariables {
alias_variables.lowercases_start += offsets.field_names;
alias_variables.variables_start += offsets.variables; alias_variables.variables_start += offsets.variables;
alias_variables alias_variables
@ -3366,9 +3358,9 @@ fn deep_copy_var_to_help<'a>(
} }
Alias(symbol, mut args, real_type_var) => { Alias(symbol, mut args, real_type_var) => {
let mut new_vars = Vec::with_capacity_in(args.variables().len(), arena); let mut new_vars = Vec::with_capacity_in(args.len(), arena);
for var_index in args.variables() { for var_index in args.into_iter() {
let var = source[var_index]; let var = source[var_index];
let new_var = deep_copy_var_to_help(arena, visited, source, target, max_rank, var); let new_var = deep_copy_var_to_help(arena, visited, source, target, max_rank, var);
@ -3377,12 +3369,6 @@ fn deep_copy_var_to_help<'a>(
args.replace_variables(target, new_vars); args.replace_variables(target, new_vars);
let lowercases = &source.field_names[args.lowercases_start as usize..]
[..args.lowercases_len as usize];
args.lowercases_start = target.field_names.len() as u32;
target.field_names.extend(lowercases.iter().cloned());
let new_real_type_var = let new_real_type_var =
deep_copy_var_to_help(arena, visited, source, target, max_rank, real_type_var); deep_copy_var_to_help(arena, visited, source, target, max_rank, real_type_var);
let new_content = Alias(symbol, args, new_real_type_var); let new_content = Alias(symbol, args, new_real_type_var);

8
compiler/types/src/types.rs
View file

@ -1241,7 +1241,7 @@ pub enum ErrorType {
TagUnion(SendMap<TagName, Vec<ErrorType>>, TypeExt), TagUnion(SendMap<TagName, Vec<ErrorType>>, TypeExt),
RecursiveTagUnion(Box<ErrorType>, SendMap<TagName, Vec<ErrorType>>, TypeExt), RecursiveTagUnion(Box<ErrorType>, SendMap<TagName, Vec<ErrorType>>, TypeExt),
Function(Vec<ErrorType>, Box<ErrorType>, Box<ErrorType>), Function(Vec<ErrorType>, Box<ErrorType>, Box<ErrorType>),
Alias(Symbol, Vec<(Lowercase, ErrorType)>, Box<ErrorType>), Alias(Symbol, Vec<ErrorType>, Box<ErrorType>),
Error, Error,
} }
@ -1303,7 +1303,7 @@ fn write_error_type_help(
Alias(Symbol::NUM_NUM, mut arguments, _actual) => { Alias(Symbol::NUM_NUM, mut arguments, _actual) => {
debug_assert!(arguments.len() == 1); debug_assert!(arguments.len() == 1);
let argument = arguments.remove(0).1; let argument = arguments.remove(0);
match argument { match argument {
Type(Symbol::NUM_INTEGER, _) => { Type(Symbol::NUM_INTEGER, _) => {
@ -1421,7 +1421,7 @@ fn write_debug_error_type_help(error_type: ErrorType, buf: &mut String, parens:
Alias(Symbol::NUM_NUM, mut arguments, _actual) => { Alias(Symbol::NUM_NUM, mut arguments, _actual) => {
debug_assert!(arguments.len() == 1); debug_assert!(arguments.len() == 1);
let argument = arguments.remove(0).1; let argument = arguments.remove(0);
match argument { match argument {
Type(Symbol::NUM_INTEGER, _) => { Type(Symbol::NUM_INTEGER, _) => {
@ -1456,7 +1456,7 @@ fn write_debug_error_type_help(error_type: ErrorType, buf: &mut String, parens:
for arg in arguments { for arg in arguments {
buf.push(' '); buf.push(' ');
write_debug_error_type_help(arg.1, buf, Parens::InTypeParam); write_debug_error_type_help(arg, buf, Parens::InTypeParam);
} }
// useful for debugging // useful for debugging

3
compiler/unify/src/unify.rs
View file

@ -209,7 +209,8 @@ fn unify_alias(
problems problems
} else { } else {
mismatch!("{}", symbol) dbg!(args.len(), other_args.len());
mismatch!("{:?}", symbol)
} }
} else { } else {
unify_pool(subs, pool, real_var, *other_real_var) unify_pool(subs, pool, real_var, *other_real_var)

15
reporting/src/error/type.rs
View file

@ -1493,7 +1493,7 @@ pub fn to_doc<'b>(
parens, parens,
alloc.symbol_foreign_qualified(symbol), alloc.symbol_foreign_qualified(symbol),
args.into_iter() args.into_iter()
.map(|(_, arg)| to_doc(alloc, Parens::InTypeParam, arg)) .map(|arg| to_doc(alloc, Parens::InTypeParam, arg))
.collect(), .collect(),
), ),
@ -1657,10 +1657,7 @@ fn to_diff<'b>(
} }
(Alias(symbol1, args1, _), Alias(symbol2, args2, _)) if symbol1 == symbol2 => { (Alias(symbol1, args1, _), Alias(symbol2, args2, _)) if symbol1 == symbol2 => {
// TODO remove collects let args_diff = traverse(alloc, Parens::InTypeParam, args1, args2);
let a1 = args1.into_iter().map(|(_, v)| v).collect::<Vec<_>>();
let a2 = args2.into_iter().map(|(_, v)| v).collect::<Vec<_>>();
let args_diff = traverse(alloc, Parens::InTypeParam, a1, a2);
let left = report_text::apply( let left = report_text::apply(
alloc, alloc,
parens, parens,
@ -1729,8 +1726,8 @@ fn to_diff<'b>(
ErrorType::Alias(Symbol::NUM_NUM, args, _) => { ErrorType::Alias(Symbol::NUM_NUM, args, _) => {
matches!( matches!(
&args.get(0), &args.get(0),
Some((_, ErrorType::Type(Symbol::NUM_INTEGER, _))) Some(ErrorType::Type(Symbol::NUM_INTEGER, _))
| Some((_, ErrorType::Alias(Symbol::NUM_INTEGER, _, _))) | Some(ErrorType::Alias(Symbol::NUM_INTEGER, _, _))
) )
} }
_ => false, _ => false,
@ -1750,8 +1747,8 @@ fn to_diff<'b>(
ErrorType::Alias(Symbol::NUM_NUM, args, _) => { ErrorType::Alias(Symbol::NUM_NUM, args, _) => {
matches!( matches!(
&args.get(0), &args.get(0),
Some((_, ErrorType::Type(Symbol::NUM_FLOATINGPOINT, _))) Some(ErrorType::Type(Symbol::NUM_FLOATINGPOINT, _))
| Some((_, ErrorType::Alias(Symbol::NUM_FLOATINGPOINT, _, _))) | Some(ErrorType::Alias(Symbol::NUM_FLOATINGPOINT, _, _))
) )
} }
_ => false, _ => false,