language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-27 22:09:09 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

remove ATTR_ATTR usage

Browse source
This commit is contained in:
Folkert 2021-04-04 23:18:50 +02:00
parent fa7dec2997
commit 62da85cc06
7 changed files with 37 additions and 265 deletions
Download patch file Download diff file Expand all files Collapse all files

17
compiler/mono/src/ir.rs
View file

@ -2103,17 +2103,6 @@ fn build_specialized_proc_from_var<'a>(
ret_var,
)
}
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args))
if !pattern_symbols.is_empty() =>
{
build_specialized_proc_from_var(
env,
layout_cache,
proc_name,
pattern_symbols,
args[1],
)
}
Content::Alias(_, _, actual) => build_specialized_proc_from_var(
env,
layout_cache,
@ -7142,12 +7131,6 @@ pub fn num_argument_to_int_or_float(
| Content::Alias(Symbol::NUM_AT_UNSIGNED8, _, _) => {
IntOrFloat::UnsignedIntType(IntPrecision::I8)
}
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, attr_args)) => {
debug_assert!(attr_args.len() == 2);
// Recurse on the second argument
num_argument_to_int_or_float(subs, ptr_bytes, attr_args[1], false)
}
Content::Alias(Symbol::NUM_FLOATINGPOINT, args, _) => {
debug_assert!(args.len() == 1);

41
compiler/mono/src/layout.rs
View file

@ -1454,9 +1454,6 @@ pub fn union_sorted_tags<'a>(
fn get_recursion_var(subs: &Subs, var: Variable) -> Option<Variable> {
match subs.get_without_compacting(var).content {
Content::Structure(FlatType::RecursiveTagUnion(rec_var, _, _)) => Some(rec_var),
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args)) => {
get_recursion_var(subs, args[1])
}
Content::Alias(_, _, actual) => get_recursion_var(subs, actual),
_ => None,
}
@ -1820,18 +1817,6 @@ fn layout_from_num_content<'a>(content: Content) -> Result<Layout<'a>, LayoutPro
fn unwrap_num_tag<'a>(subs: &Subs, var: Variable) -> Result<Layout<'a>, LayoutProblem> {
match subs.get_without_compacting(var).content {
Content::Structure(flat_type) => match flat_type {
FlatType::Apply(Symbol::ATTR_ATTR, args) => {
debug_assert_eq!(args.len(), 2);
let arg_var = args.get(1).unwrap();
unwrap_num_tag(subs, *arg_var)
}
_ => {
todo!("TODO handle Num.@Num flat_type {:?}", flat_type);
}
},
Content::Alias(Symbol::NUM_INTEGER, args, _) => {
debug_assert!(args.len() == 1);
@ -1908,27 +1893,12 @@ fn dict_layout_from_key_value<'a>(
value_var: Variable,
) -> Result<Layout<'a>, LayoutProblem> {
match env.subs.get_without_compacting(key_var).content {
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, key_args)) => {
debug_assert_eq!(key_args.len(), 2);
let var = *key_args.get(1).unwrap();
dict_layout_from_key_value(env, var, value_var)
}
Content::FlexVar(_) | Content::RigidVar(_) => {
// If this was still a (Dict * *) then it must have been an empty dict
Ok(Layout::Builtin(Builtin::EmptyDict))
}
key_content => {
match env.subs.get_without_compacting(value_var).content {
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, value_args)) => {
debug_assert_eq!(value_args.len(), 2);
let var = *value_args.get(1).unwrap();
dict_layout_from_key_value(env, key_var, var)
}
value_content => {
let value_content = env.subs.get_without_compacting(value_var).content;
let key_layout = Layout::new_help(env, key_var, key_content)?;
let value_layout = Layout::new_help(env, value_var, value_content)?;
@ -1939,8 +1909,6 @@ fn dict_layout_from_key_value<'a>(
)))
}
}
}
}
}
pub fn list_layout_from_elem<'a>(
@ -1948,13 +1916,6 @@ pub fn list_layout_from_elem<'a>(
elem_var: Variable,
) -> Result<Layout<'a>, LayoutProblem> {
match env.subs.get_without_compacting(elem_var).content {
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args)) => {
debug_assert_eq!(args.len(), 2);
let var = *args.get(1).unwrap();
list_layout_from_elem(env, var)
}
Content::FlexVar(_) | Content::RigidVar(_) => {
// If this was still a (List *) then it must have been an empty list
Ok(Layout::Builtin(Builtin::EmptyList))

1
compiler/reporting/src/error/type.rs
View file

@ -823,7 +823,6 @@ fn count_arguments(tipe: &ErrorType) -> usize {
match tipe {
Function(args, _, _) => args.len(),
Type(Symbol::ATTR_ATTR, args) => count_arguments(&args[1]),
Alias(_, _, actual) => count_arguments(actual),
_ => 0,
}

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

@ -1,7 +1,6 @@
use roc_can::constraint::Constraint::{self, *};
use roc_can::expected::{Expected, PExpected};
use roc_collections::all::{ImMap, MutMap};
use roc_module::ident::TagName;
use roc_module::symbol::Symbol;
use roc_region::all::{Located, Region};
use roc_types::solved_types::Solved;
@ -872,19 +871,13 @@ fn check_for_infinite_type(
) {
let var = loc_var.value;
let is_uniq_infer = matches!(
subs.get_ref(var).content,
Content::Alias(Symbol::ATTR_ATTR, _, _)
);
while let Some((recursive, chain)) = subs.occurs(var) {
while let Some((recursive, _chain)) = subs.occurs(var) {
let description = subs.get(recursive);
let content = description.content;
// try to make a tag union recursive, see if that helps
match content {
Content::Structure(FlatType::TagUnion(tags, ext_var)) => {
if !is_uniq_infer {
let rec_var = subs.fresh_unnamed_flex_var();
subs.set_rank(rec_var, description.rank);
subs.set_content(
@ -911,59 +904,6 @@ fn check_for_infinite_type(
let flat_type = FlatType::RecursiveTagUnion(rec_var, new_tags, new_ext_var);
subs.set_content(recursive, Content::Structure(flat_type));
} else {
// Sometimes, the recursion "starts" at the tag-union, not an `Attr`. Here we
// We use the path that `occurs` took to find the recursion to go one step
// forward in the recursion and find the `Attr` there.
let index = 0;
match subs.get(chain[index]).content {
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args)) => {
debug_assert!(args.len() == 2);
debug_assert!(
subs.get_root_key_without_compacting(recursive)
== subs.get_root_key_without_compacting(args[1])
);
// NOTE this ensures we use the same uniqueness var for the whole spine
// that might add too much uniqueness restriction.
// using `subs.fresh_unnamed_flex_var()` loosens it.
let uniq_var = args[0];
let tag_union_var = recursive;
let recursive = chain[index];
correct_recursive_attr(
subs,
recursive,
uniq_var,
tag_union_var,
ext_var,
description.rank,
&tags,
);
}
_ => circular_error(subs, problems, symbol, &loc_var),
}
}
}
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args)) => {
debug_assert!(args.len() == 2);
let uniq_var = args[0];
let tag_union_var = args[1];
let nested_description = subs.get(tag_union_var);
match nested_description.content {
Content::Structure(FlatType::TagUnion(tags, ext_var)) => {
correct_recursive_attr(
subs,
recursive,
uniq_var,
tag_union_var,
ext_var,
description.rank,
&tags,
);
}
_ => circular_error(subs, problems, symbol, &loc_var),
}
}
_other => circular_error(subs, problems, symbol, &loc_var),
@ -971,54 +911,6 @@ fn check_for_infinite_type(
}
}
fn content_attr(u: Variable, a: Variable) -> Content {
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, vec![u, a]))
}
fn correct_recursive_attr(
subs: &mut Subs,
recursive: Variable,
uniq_var: Variable,
tag_union_var: Variable,
ext_var: Variable,
recursion_var_rank: Rank,
tags: &MutMap<TagName, Vec<Variable>>,
) {
let rec_var = subs.fresh_unnamed_flex_var();
let attr_var = subs.fresh_unnamed_flex_var();
let content = content_attr(uniq_var, rec_var);
subs.set_content(attr_var, content);
subs.set_rank(rec_var, recursion_var_rank);
subs.set_content(
rec_var,
Content::RecursionVar {
opt_name: None,
structure: recursive,
},
);
let mut new_tags = MutMap::default();
let new_ext_var = subs.explicit_substitute(recursive, attr_var, ext_var);
for (label, args) in tags {
let new_args: Vec<_> = args
.iter()
.map(|var| subs.explicit_substitute(recursive, attr_var, *var))
.collect();
new_tags.insert(label.clone(), new_args);
}
let new_tag_type = FlatType::RecursiveTagUnion(rec_var, new_tags, new_ext_var);
subs.set_content(tag_union_var, Content::Structure(new_tag_type));
let new_recursive = content_attr(uniq_var, tag_union_var);
subs.set_content(recursive, new_recursive);
}
fn circular_error(
subs: &mut Subs,
problems: &mut Vec<TypeError>,

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

@ -140,11 +140,6 @@ fn find_names_needed(
// We must not accidentally generate names that collide with them!
names_taken.insert(name);
}
Structure(Apply(Symbol::ATTR_ATTR, args)) => {
// assign uniqueness var names based on when they occur in the base type
find_names_needed(args[1], subs, roots, root_appearances, names_taken);
find_names_needed(args[0], subs, roots, root_appearances, names_taken);
}
Structure(Apply(_, args)) => {
for var in args {
find_names_needed(var, subs, roots, root_appearances, names_taken);
@ -195,18 +190,13 @@ fn find_names_needed(
find_names_needed(ext_var, subs, roots, root_appearances, names_taken);
find_names_needed(rec_var, subs, roots, root_appearances, names_taken);
}
Alias(symbol, args, _actual) => {
if let Symbol::ATTR_ATTR = symbol {
find_names_needed(args[0].1, subs, roots, root_appearances, names_taken);
find_names_needed(args[1].1, subs, roots, root_appearances, names_taken);
} else {
Alias(_symbol, args, _actual) => {
for (_, var) in args {
find_names_needed(var, subs, roots, root_appearances, names_taken);
}
// TODO should we also look in the actual variable?
// find_names_needed(_actual, subs, roots, root_appearances, names_taken);
}
}
Error | Structure(Erroneous(_)) | Structure(EmptyRecord) | Structure(EmptyTagUnion) => {
// Errors and empty records don't need names.
}
@ -325,24 +315,6 @@ fn write_content(env: &Env, content: Content, subs: &Subs, buf: &mut String, par
}),
},
Structure(FlatType::Apply(Symbol::ATTR_ATTR, nested_args)) => {
let attr_content = subs.get_without_compacting(nested_args[1]).content;
match &attr_content {
Alias(nested, _, _) => match *nested {
Symbol::NUM_INTEGER => buf.push_str("I64"),
Symbol::NUM_FLOATINGPOINT => buf.push_str("F64"),
_ => write_parens!(write_parens, buf, {
buf.push_str("Num ");
write_content(env, content, subs, buf, parens);
}),
},
_ => write_parens!(write_parens, buf, {
buf.push_str("Num ");
write_content(env, content, subs, buf, parens);
}),
}
}
_ => write_parens!(write_parens, buf, {
buf.push_str("Num ");
write_content(env, content, subs, buf, parens);
@ -598,11 +570,6 @@ pub fn chase_ext_tag_union(
chase_ext_tag_union(subs, ext_var, fields)
}
Content::Structure(Apply(Symbol::ATTR_ATTR, arguments)) => {
debug_assert_eq!(arguments.len(), 2);
chase_ext_tag_union(subs, arguments[1], fields)
}
Content::Alias(_, _, var) => chase_ext_tag_union(subs, var, fields),
content => Err((var, content)),
@ -626,12 +593,6 @@ pub fn chase_ext_record(
Structure(EmptyRecord) => Ok(()),
Content::Structure(Apply(Symbol::ATTR_ATTR, arguments)) => {
debug_assert_eq!(arguments.len(), 2);
chase_ext_record(subs, arguments[1], fields)
}
Alias(_, _, var) => chase_ext_record(subs, var, fields),
content => Err((var, content)),
@ -683,25 +644,6 @@ fn write_apply(
Symbol::NUM_FLOATINGPOINT if nested_args.len() == 1 => {
buf.push_str("F64");
}
Symbol::ATTR_ATTR => match nested_args
.get(1)
.map(|v| subs.get_without_compacting(*v).content)
{
Some(Content::Structure(FlatType::Apply(
double_nested_symbol,
double_nested_args,
))) => match double_nested_symbol {
Symbol::NUM_INTEGER if double_nested_args.len() == 1 => {
buf.push_str("I64");
}
Symbol::NUM_FLOATINGPOINT if double_nested_args.len() == 1 => {
buf.push_str("F64");
}
_ => default_case(subs, arg_content),
},
_other => default_case(subs, arg_content),
},
_ => default_case(subs, arg_content),
},
_ => default_case(subs, arg_content),

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

@ -363,11 +363,7 @@ impl Type {
}
}
pub fn is_recursive(&self) -> bool {
match self {
Type::RecursiveTagUnion(_, _, _) => true,
Type::Alias(Symbol::ATTR_ATTR, _, actual) => actual.is_recursive(),
_ => false,
}
matches!(self, Type::RecursiveTagUnion(_, _, _))
}
pub fn variables(&self) -> ImSet<Variable> {

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

@ -704,7 +704,6 @@ fn unify_tag_union_not_recursive_recursive(
fn is_structure(var: Variable, subs: &mut Subs) -> bool {
match subs.get(var).content {
Content::Alias(_, _, actual) => is_structure(actual, subs),
Content::Structure(FlatType::Apply(Symbol::ATTR_ATTR, args)) => is_structure(args[1], subs),
Content::Structure(_) => true,
_ => false,
}