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

make VariableSubsSlice an alias

Browse source
This commit is contained in:
Folkert 2021-11-25 20:29:34 +01:00
parent 69a80872e1
commit 612f868652
7 changed files with 50 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

12
cli/src/repl/eval.rs
View file

@ -647,8 +647,8 @@ fn unpack_single_element_tag_union(subs: &Subs, tags: UnionTags) -> (&TagName, &
let (tag_name_index, payload_vars_index) = tags.iter_all().next().unwrap();
let tag_name = &subs[tag_name_index];
let subs_slice = subs[payload_vars_index].as_subs_slice();
let payload_vars = subs.get_subs_slice(*subs_slice);
let subs_slice = subs[payload_vars_index];
let payload_vars = subs.get_subs_slice(subs_slice);
(tag_name, payload_vars)
}
@ -661,14 +661,14 @@ fn unpack_two_element_tag_union(
let (tag_name_index, payload_vars_index) = it.next().unwrap();
let tag_name1 = &subs[tag_name_index];
let subs_slice = subs[payload_vars_index].as_subs_slice();
let payload_vars1 = subs.get_subs_slice(*subs_slice);
let subs_slice = subs[payload_vars_index];
let payload_vars1 = subs.get_subs_slice(subs_slice);
let (tag_name_index, payload_vars_index) = it.next().unwrap();
let tag_name2 = &subs[tag_name_index];
let subs_slice = subs[payload_vars_index].as_subs_slice();
let payload_vars2 = subs.get_subs_slice(*subs_slice);
let subs_slice = subs[payload_vars_index];
let payload_vars2 = subs.get_subs_slice(subs_slice);
(tag_name1, payload_vars1, tag_name2, payload_vars2)
}

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

@ -906,7 +906,7 @@ fn alias_to_var<'a>(
}
AliasVariables {
variables_start: new_variables.slice.start,
variables_start: new_variables.start,
type_variables_len: type_arguments.len() as _,
all_variables_len: length as _,
}
@ -1501,7 +1501,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
macro_rules! var_slice {
($variable_subs_slice:expr) => {{
let slice = $variable_subs_slice;
&subs.variables[slice.slice.start as usize..][..slice.slice.length as usize]
&subs.variables[slice.indices()]
}};
}
@ -1570,7 +1570,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
let ext_var = *ext_var;
for slice_index in tags.variables() {
let slice = subs.variable_slices[slice_index.start as usize];
let slice = subs.variable_slices[slice_index.index as usize];
stack.extend(var_slice!(slice));
}
@ -1586,7 +1586,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
let rec_var = *rec_var;
for slice_index in tags.variables() {
let slice = subs.variable_slices[slice_index.start as usize];
let slice = subs.variable_slices[slice_index.index as usize];
stack.extend(var_slice!(slice));
}
@ -1736,7 +1736,7 @@ fn deep_copy_var_help(
RecordFields {
length: fields.length,
field_names_start: fields.field_names_start,
variables_start: new_variables.slice.start,
variables_start: new_variables.start,
field_types_start: fields.field_types_start,
}
};
@ -1844,7 +1844,7 @@ fn deep_copy_var_help(
}
let new_arguments = AliasVariables {
variables_start: new_variables.slice.start,
variables_start: new_variables.start,
..arguments
};

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

@ -504,24 +504,14 @@ fn write_flat_type(env: &Env, flat_type: &FlatType, subs: &Subs, buf: &mut Strin
use crate::subs::FlatType::*;
match flat_type {
Apply(symbol, args) => write_apply(
env,
*symbol,
subs.get_subs_slice(*args.as_subs_slice()),
subs,
buf,
parens,
),
Apply(symbol, args) => {
write_apply(env, *symbol, subs.get_subs_slice(*args), subs, buf, parens)
}
EmptyRecord => buf.push_str(EMPTY_RECORD),
EmptyTagUnion => buf.push_str(EMPTY_TAG_UNION),
Func(args, _closure, ret) => write_fn(
env,
subs.get_subs_slice(*args.as_subs_slice()),
*ret,
subs,
buf,
parens,
),
Func(args, _closure, ret) => {
write_fn(env, subs.get_subs_slice(*args), *ret, subs, buf, parens)
}
Record(fields, ext_var) => {
use crate::types::{gather_fields, RecordStructure};
@ -640,7 +630,7 @@ pub fn chase_ext_tag_union<'a>(
Content::Structure(TagUnion(tags, ext_var)) => {
for (name_index, slice_index) in tags.iter_all() {
let subs_slice = subs[slice_index];
let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
let slice = subs.get_subs_slice(subs_slice);
let tag_name = subs[name_index].clone();
fields.push((tag_name, slice.to_vec()));
@ -652,7 +642,7 @@ pub fn chase_ext_tag_union<'a>(
Content::Structure(RecursiveTagUnion(_, tags, ext_var)) => {
for (name_index, slice_index) in tags.iter_all() {
let subs_slice = subs[slice_index];
let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
let slice = subs.get_subs_slice(subs_slice);
let tag_name = subs[name_index].clone();
fields.push((tag_name, slice.to_vec()));

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

@ -299,7 +299,7 @@ impl SolvedType {
Apply(symbol, args) => {
let mut new_args = Vec::with_capacity(args.len());
for var in subs.get_subs_slice(*args.as_subs_slice()) {
for var in subs.get_subs_slice(*args) {
new_args.push(Self::from_var_help(subs, recursion_vars, *var));
}
@ -308,7 +308,7 @@ impl SolvedType {
Func(args, closure, ret) => {
let mut new_args = Vec::with_capacity(args.len());
for var in subs.get_subs_slice(*args.as_subs_slice()) {
for var in subs.get_subs_slice(*args) {
new_args.push(Self::from_var_help(subs, recursion_vars, *var));
}

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

@ -367,7 +367,7 @@ fn subs_fmt_content(this: &Content, subs: &Subs, f: &mut fmt::Formatter) -> fmt:
} => write!(f, "Recursion({:?}, {:?})", structure, opt_name),
Content::Structure(flat_type) => subs_fmt_flat_type(flat_type, subs, f),
Content::Alias(name, arguments, actual) => {
let slice = subs.get_subs_slice(*arguments.variables().as_subs_slice());
let slice = subs.get_subs_slice(arguments.variables());
write!(f, "Alias({:?}, {:?}, {:?})", name, slice, actual)
}
@ -386,12 +386,12 @@ impl<'a> fmt::Debug for SubsFmtFlatType<'a> {
fn subs_fmt_flat_type(this: &FlatType, subs: &Subs, f: &mut fmt::Formatter) -> fmt::Result {
match this {
FlatType::Apply(name, arguments) => {
let slice = subs.get_subs_slice(*arguments.as_subs_slice());
let slice = subs.get_subs_slice(*arguments);
write!(f, "Apply({:?}, {:?})", name, slice)
}
FlatType::Func(arguments, lambda_set, result) => {
let slice = subs.get_subs_slice(*arguments.as_subs_slice());
let slice = subs.get_subs_slice(*arguments);
write!(f, "Func({:?}, {:?}, {:?})", slice, lambda_set, result)
}
FlatType::Record(fields, ext) => {
@ -1425,9 +1425,7 @@ pub struct AliasVariables {
impl AliasVariables {
pub const fn variables(&self) -> VariableSubsSlice {
VariableSubsSlice {
slice: SubsSlice::new(self.variables_start, self.all_variables_len),
}
SubsSlice::new(self.variables_start, self.all_variables_len)
}
pub const fn len(&self) -> usize {
@ -1555,34 +1553,9 @@ pub enum Builtin {
EmptyRecord,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct VariableSubsSlice {
pub slice: SubsSlice<Variable>,
}
pub type VariableSubsSlice = SubsSlice<Variable>;
impl VariableSubsSlice {
pub fn len(&self) -> usize {
self.slice.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn as_subs_slice(&self) -> &SubsSlice<Variable> {
&self.slice
}
pub fn new(start: u32, length: u16) -> Self {
Self {
slice: SubsSlice::new(start, length),
}
}
pub fn indices(&self) -> std::ops::Range<usize> {
self.slice.indices()
}
/// Reserve space for `length` variables in the subs.variables array
///
/// This is useful when we know how many variables e.g. a loop will produce,
@ -1614,16 +1587,6 @@ impl VariableSubsSlice {
}
}
impl IntoIterator for VariableSubsSlice {
type Item = SubsIndex<Variable>;
type IntoIter = <SubsSlice<Variable> as IntoIterator>::IntoIter;
fn into_iter(self) -> Self::IntoIter {
self.slice.into_iter()
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct UnionTags {
length: u16,
@ -1637,7 +1600,7 @@ impl UnionTags {
return false;
}
let slice = subs.variable_slices[self.variables_start as usize].slice;
let slice = subs.variable_slices[self.variables_start as usize];
slice.length == 1
}
@ -1764,7 +1727,9 @@ impl UnionTags {
) -> impl Iterator<Item = (&TagName, &[Variable])> + 'a {
let (it, _) = crate::types::gather_tags_unsorted_iter(subs, *self, ext);
it.map(move |(label, slice)| (label, subs.get_subs_slice(*slice.as_subs_slice())))
let f = move |(label, slice): (_, SubsSlice<Variable>)| (label, subs.get_subs_slice(slice));
it.map(f)
}
pub fn unsorted_iterator_and_ext<'a>(
@ -1774,10 +1739,9 @@ impl UnionTags {
) -> (impl Iterator<Item = (&TagName, &[Variable])> + 'a, Variable) {
let (it, ext) = crate::types::gather_tags_unsorted_iter(subs, *self, ext);
(
it.map(move |(label, slice)| (label, subs.get_subs_slice(*slice.as_subs_slice()))),
ext,
)
let f = move |(label, slice): (_, SubsSlice<Variable>)| (label, subs.get_subs_slice(slice));
(it.map(f), ext)
}
#[inline(always)]
@ -1792,7 +1756,7 @@ impl UnionTags {
let tag_name: &TagName = &subs[i1];
let subs_slice = subs[i2];
let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
let slice = subs.get_subs_slice(subs_slice);
(tag_name.clone(), slice)
})),
@ -1903,9 +1867,7 @@ impl RecordFields {
}
pub const fn variables(&self) -> VariableSubsSlice {
let slice = SubsSlice::new(self.variables_start, self.length);
VariableSubsSlice { slice }
SubsSlice::new(self.variables_start, self.length)
}
pub fn iter_variables(&self) -> impl Iterator<Item = SubsIndex<Variable>> {
@ -2081,16 +2043,13 @@ fn occurs(
new_seen.insert(root_var);
match flat_type {
Apply(_, args) => short_circuit(
subs,
root_var,
&new_seen,
subs.get_subs_slice(*args.as_subs_slice()).iter(),
),
Apply(_, args) => {
short_circuit(subs, root_var, &new_seen, subs.get_subs_slice(*args).iter())
}
Func(arg_vars, closure_var, ret_var) => {
let it = once(ret_var)
.chain(once(closure_var))
.chain(subs.get_subs_slice(*arg_vars.as_subs_slice()).iter());
.chain(subs.get_subs_slice(*arg_vars).iter());
short_circuit(subs, root_var, &new_seen, it)
}
Record(vars_by_field, ext_var) => {
@ -2798,10 +2757,8 @@ fn restore_help(subs: &mut Subs, initial: Variable) {
let variable_slices = &subs.variable_slices;
let variables = &subs.variables;
let var_slice = |variable_subs_slice: VariableSubsSlice| {
&variables[variable_subs_slice.slice.start as usize..]
[..variable_subs_slice.slice.length as usize]
};
let var_slice =
|variable_subs_slice: VariableSubsSlice| &variables[variable_subs_slice.indices()];
while let Some(var) = stack.pop() {
let desc = &mut subs.utable.probe_value_ref_mut(var).value;
@ -3082,7 +3039,7 @@ impl StorageSubs {
offsets: &StorageSubsOffsets,
mut slice: VariableSubsSlice,
) -> VariableSubsSlice {
slice.slice.start += offsets.variables;
slice.start += offsets.variables;
slice
}

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

@ -1765,7 +1765,7 @@ pub fn gather_tags_slices(
let (it, ext) = gather_tags_unsorted_iter(subs, other_fields, var);
let mut result: Vec<_> = it
.map(|(ref_label, field)| (ref_label.clone(), field))
.map(|(ref_label, field): (_, VariableSubsSlice)| (ref_label.clone(), field))
.collect();
result.sort_by(|(a, _), (b, _)| a.cmp(b));
@ -1777,11 +1777,8 @@ pub fn gather_tags(subs: &Subs, other_fields: UnionTags, var: Variable) -> TagUn
let (it, ext) = gather_tags_unsorted_iter(subs, other_fields, var);
let mut result: Vec<_> = it
.map(|(ref_label, field)| {
(
ref_label.clone(),
subs.get_subs_slice(*field.as_subs_slice()),
)
.map(|(ref_label, field): (_, VariableSubsSlice)| {
(ref_label.clone(), subs.get_subs_slice(field))
})
.collect();

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

@ -842,7 +842,7 @@ fn unify_shared_tags_new(
all_fields = merge_sorted(
all_fields,
other1.into_iter().map(|(field_name, subs_slice)| {
let vec = subs.get_subs_slice(*subs_slice.as_subs_slice()).to_vec();
let vec = subs.get_subs_slice(subs_slice).to_vec();
(field_name, vec)
}),
@ -851,7 +851,7 @@ fn unify_shared_tags_new(
all_fields = merge_sorted(
all_fields,
other2.into_iter().map(|(field_name, subs_slice)| {
let vec = subs.get_subs_slice(*subs_slice.as_subs_slice()).to_vec();
let vec = subs.get_subs_slice(subs_slice).to_vec();
(field_name, vec)
}),
@ -969,8 +969,7 @@ fn unify_flat_type(
}
(Apply(l_symbol, l_args), Apply(r_symbol, r_args)) if l_symbol == r_symbol => {
let problems =
unify_zip_slices(subs, pool, *l_args.as_subs_slice(), *r_args.as_subs_slice());
let problems = unify_zip_slices(subs, pool, *l_args, *r_args);
if problems.is_empty() {
merge(subs, ctx, Structure(Apply(*r_symbol, *r_args)))
@ -981,8 +980,7 @@ fn unify_flat_type(
(Func(l_args, l_closure, l_ret), Func(r_args, r_closure, r_ret))
if l_args.len() == r_args.len() =>
{
let arg_problems =
unify_zip_slices(subs, pool, *l_args.as_subs_slice(), *r_args.as_subs_slice());
let arg_problems = unify_zip_slices(subs, pool, *l_args, *r_args);
let ret_problems = unify_pool(subs, pool, *l_ret, *r_ret);
let closure_problems = unify_pool(subs, pool, *l_closure, *r_closure);