language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-03 16:44:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

get rid of Container

Browse source
This commit is contained in:
Folkert 2020-07-18 00:57:27 +02:00
parent ce8bcbb5ed
commit 25329ad672
3 changed files with 92 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

8
compiler/constrain/src/uniq.rs
View file

@ -1438,8 +1438,8 @@ fn constrain_var(
// no additional constraints, keep uniqueness unbound // no additional constraints, keep uniqueness unbound
Lookup(symbol_for_lookup, expected, region) Lookup(symbol_for_lookup, expected, region)
} }
Some(Usage::RecordAccess(_, _, _)) Some(Usage::RecordAccess(_, _))
| Some(Usage::RecordUpdate(_, _, _)) | Some(Usage::RecordUpdate(_, _))
| Some(Usage::ApplyAccess(_, _)) | Some(Usage::ApplyAccess(_, _))
| Some(Usage::ApplyUpdate(_, _)) => { | Some(Usage::ApplyUpdate(_, _)) => {
applied_usage_constraint.insert(symbol_for_lookup); applied_usage_constraint.insert(symbol_for_lookup);
@ -1487,12 +1487,12 @@ fn constrain_by_usage(
(Bool::container(uvar, vec![]), Type::Variable(var)) (Bool::container(uvar, vec![]), Type::Variable(var))
} }
Usage::RecordAccess(_, mark, fields) => { Usage::RecordAccess(mark, fields) => {
let (record_bool, ext_type) = constrain_by_usage(&Simple(*mark), var_store, introduced); let (record_bool, ext_type) = constrain_by_usage(&Simple(*mark), var_store, introduced);
constrain_by_usage_record(fields, record_bool, ext_type, introduced, var_store) constrain_by_usage_record(fields, record_bool, ext_type, introduced, var_store)
} }
Usage::RecordUpdate(_, _, fields) => { Usage::RecordUpdate(_, fields) => {
let record_uvar = var_store.fresh(); let record_uvar = var_store.fresh();
introduced.push(record_uvar); introduced.push(record_uvar);

134
compiler/uniq/src/sharing.rs
View file

@ -37,8 +37,8 @@ pub enum Usage {
ApplyUpdate(ImSet<usize>, FieldAccess), ApplyUpdate(ImSet<usize>, FieldAccess),
// Records // Records
RecordAccess(Container, Mark, FieldAccess), RecordAccess(Mark, FieldAccess),
RecordUpdate(Container, ImSet<Lowercase>, FieldAccess), RecordUpdate(ImSet<Lowercase>, FieldAccess),
} }
#[derive(Debug, PartialEq, Eq, Clone, Copy)] #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@ -108,78 +108,74 @@ impl Composable for Usage {
} }
// Record Update // Record Update
(RecordUpdate(c1, _, _), RecordUpdate(c2, _, _)) (RecordUpdate(_, _), RecordUpdate(_, _)) | (RecordUpdate(_, _), RecordAccess(_, _)) => {
| (RecordUpdate(c1, _, _), RecordAccess(c2, _, _)) => {
debug_assert_eq!(c1, c2);
*self = Simple(Shared); *self = Simple(Shared);
} }
(RecordUpdate(_, _, _), Simple(Unique)) | (Simple(Unique), RecordUpdate(_, _, _)) => { (RecordUpdate(_, _), Simple(Unique)) | (Simple(Unique), RecordUpdate(_, _)) => {
*self = Simple(Shared); *self = Simple(Shared);
} }
(RecordAccess(c1, m1, fields1), RecordUpdate(c2, overwritten, fields2)) => { (RecordAccess(m1, fields1), RecordUpdate(overwritten, fields2)) => {
debug_assert_eq!(c1, c2);
*self = correct_overwritten(*m1, fields1, Seen, fields2, overwritten); *self = correct_overwritten(*m1, fields1, Seen, fields2, overwritten);
} }
(Simple(Seen), RecordUpdate(c1, overwritten, fa)) => { (Simple(Seen), RecordUpdate(overwritten, fa)) => {
*self = RecordUpdate(*c1, overwritten.clone(), fa.clone()); *self = RecordUpdate(overwritten.clone(), fa.clone());
} }
(RecordUpdate(c1, overwritten, fa), Simple(Seen)) => { (RecordUpdate(overwritten, fa), Simple(Seen)) => {
*self = RecordUpdate(*c1, overwritten.clone(), fa.clone()); *self = RecordUpdate(overwritten.clone(), fa.clone());
} }
// RecordAccess // RecordAccess
(RecordAccess(c1, m1, fa1), RecordAccess(c2, m2, fa2)) => { (RecordAccess(m1, fa1), RecordAccess(m2, fa2)) => {
debug_assert_eq!(c1, c2);
let mut fa = fa1.clone(); let mut fa = fa1.clone();
fa.sequential(fa2); fa.sequential(fa2);
let mut m = *m1; let mut m = *m1;
m.sequential(m2); m.sequential(m2);
*self = RecordAccess(*c1, m, fa); *self = RecordAccess(m, fa);
} }
(RecordAccess(c1, m, fa1), Simple(Unique)) => { (RecordAccess(m, fa1), Simple(Unique)) => {
let mut copy = RecordAccess(*c1, *m, fa1.clone()); let mut copy = RecordAccess(*m, fa1.clone());
make_subtree_shared(&mut copy); make_subtree_shared(&mut copy);
// correct the mark of the top-level access // correct the mark of the top-level access
*self = if let RecordAccess(c, _, fa) = copy { *self = if let RecordAccess(_, fa) = copy {
let mut m = *m; let mut m = *m;
m.sequential(&Unique); m.sequential(&Unique);
RecordAccess(c, m, fa) RecordAccess(m, fa)
} else { } else {
unreachable!() unreachable!()
}; };
} }
(Simple(Unique), RecordAccess(c, m, fa)) => { (Simple(Unique), RecordAccess(m, fa)) => {
let mut copy = RecordAccess(*c, *m, fa.clone()); let mut copy = RecordAccess(*m, fa.clone());
make_subtree_shared(&mut copy); make_subtree_shared(&mut copy);
// correct the mark of the top-level access // correct the mark of the top-level access
*self = if let RecordAccess(c, _, fa) = copy { *self = if let RecordAccess(_, fa) = copy {
let mut m = *m; let mut m = *m;
m.sequential(&Unique); m.sequential(&Unique);
RecordAccess(c, m, fa) RecordAccess(m, fa)
} else { } else {
unreachable!() unreachable!()
}; };
} }
(Simple(m1 @ Seen), RecordAccess(c1, m2, fa)) => { (Simple(m1 @ Seen), RecordAccess(m2, fa)) => {
let mut m = *m1; let mut m = *m1;
m.sequential(m2); m.sequential(m2);
*self = RecordAccess(*c1, m, fa.clone()) *self = RecordAccess(m, fa.clone())
} }
(RecordAccess(c1, m1, fa), Simple(m2 @ Seen)) => { (RecordAccess(m1, fa), Simple(m2 @ Seen)) => {
let mut m = *m1; let mut m = *m1;
m.sequential(m2); m.sequential(m2);
*self = RecordAccess(*c1, m, fa.clone()); *self = RecordAccess(m, fa.clone());
} }
// Apply Update // Apply Update
@ -254,14 +250,14 @@ impl Composable for Usage {
} }
// Things cannot change type // Things cannot change type
(ApplyAccess(_, _), RecordAccess(_, _, _)) (ApplyAccess(_, _), RecordAccess(_, _))
| (ApplyAccess(_, _), RecordUpdate(_, _, _)) | (ApplyAccess(_, _), RecordUpdate(_, _))
| (ApplyUpdate(_, _), RecordAccess(_, _, _)) | (ApplyUpdate(_, _), RecordAccess(_, _))
| (ApplyUpdate(_, _), RecordUpdate(_, _, _)) | (ApplyUpdate(_, _), RecordUpdate(_, _))
| (RecordAccess(_, _, _), ApplyAccess(_, _)) | (RecordAccess(_, _), ApplyAccess(_, _))
| (RecordUpdate(_, _, _), ApplyAccess(_, _)) | (RecordUpdate(_, _), ApplyAccess(_, _))
| (RecordAccess(_, _, _), ApplyUpdate(_, _)) | (RecordAccess(_, _), ApplyUpdate(_, _))
| (RecordUpdate(_, _, _), ApplyUpdate(_, _)) => { | (RecordUpdate(_, _), ApplyUpdate(_, _)) => {
unreachable!("applies cannot turn into records or vice versa!") unreachable!("applies cannot turn into records or vice versa!")
} }
@ -290,59 +286,55 @@ impl Composable for Usage {
*self = Simple(Shared); *self = Simple(Shared);
} }
// Record update // Record update
(RecordUpdate(c1, w1, fa1), RecordUpdate(c2, w2, fa2)) => { (RecordUpdate(w1, fa1), RecordUpdate(w2, fa2)) => {
debug_assert_eq!(c1, c2);
let mut fa = fa1.clone(); let mut fa = fa1.clone();
fa.parallel(fa2); fa.parallel(fa2);
let w = w1.clone().intersection(w2.clone()); let w = w1.clone().intersection(w2.clone());
*self = RecordUpdate(*c1, w, fa); *self = RecordUpdate(w, fa);
} }
(RecordUpdate(_, _, _), Simple(Unique)) | (RecordUpdate(_, _, _), Simple(Seen)) => { (RecordUpdate(_, _), Simple(Unique)) | (RecordUpdate(_, _), Simple(Seen)) => {
//*self = RecordUpdate(*c1, w.clone(), fa.clone()); //*self = RecordUpdate( w.clone(), fa.clone());
} }
(Simple(Unique), RecordUpdate(c1, w, fa)) | (Simple(Seen), RecordUpdate(c1, w, fa)) => { (Simple(Unique), RecordUpdate(w, fa)) | (Simple(Seen), RecordUpdate(w, fa)) => {
*self = RecordUpdate(*c1, w.clone(), fa.clone()); *self = RecordUpdate(w.clone(), fa.clone());
} }
(RecordUpdate(c1, w, fa1), RecordAccess(c2, _, fa2)) => { (RecordUpdate(w, fa1), RecordAccess(_, fa2)) => {
debug_assert_eq!(c1, c2);
let mut fa = fa1.clone(); let mut fa = fa1.clone();
fa.parallel(&fa2.clone()); fa.parallel(&fa2.clone());
*self = RecordUpdate(*c1, w.clone(), fa); *self = RecordUpdate(w.clone(), fa);
} }
(RecordAccess(c1, _, fa1), RecordUpdate(c2, w, fa2)) => { (RecordAccess(_, fa1), RecordUpdate(w, fa2)) => {
debug_assert_eq!(c1, c2);
let mut fa = fa1.clone(); let mut fa = fa1.clone();
fa.parallel(&fa2.clone()); fa.parallel(&fa2.clone());
*self = RecordUpdate(*c1, w.clone(), fa); *self = RecordUpdate(w.clone(), fa);
} }
// Record Access // Record Access
(RecordAccess(c1, m1, fa1), RecordAccess(c2, m2, fa2)) => { (RecordAccess(m1, fa1), RecordAccess(m2, fa2)) => {
debug_assert_eq!(c1, c2);
let mut m = *m1; let mut m = *m1;
m.parallel(m2); m.parallel(m2);
let mut fa = fa1.clone(); let mut fa = fa1.clone();
fa.parallel(fa2); fa.parallel(fa2);
*self = RecordAccess(*c1, m, fa) *self = RecordAccess(m, fa)
} }
(RecordAccess(c, m, fa), Simple(Unique)) => { (RecordAccess(m, fa), Simple(Unique)) => {
let mut m = *m; let mut m = *m;
m.parallel(&Unique); m.parallel(&Unique);
*self = RecordAccess(*c, m, fa.clone()); *self = RecordAccess(m, fa.clone());
} }
(RecordAccess(_, _, _), Simple(Seen)) => { (RecordAccess(_, _), Simple(Seen)) => {
// *self = RecordAccess(*c1, *m, fa.clone()); // *self = RecordAccess( *m, fa.clone());
} }
(Simple(m1 @ Unique), RecordAccess(c1, m2, fa)) (Simple(m1 @ Unique), RecordAccess(m2, fa))
| (Simple(m1 @ Seen), RecordAccess(c1, m2, fa)) => { | (Simple(m1 @ Seen), RecordAccess(m2, fa)) => {
let mut m = *m1; let mut m = *m1;
m.sequential(m2); m.sequential(m2);
*self = RecordAccess(*c1, m, fa.clone()); *self = RecordAccess(m, fa.clone());
} }
// Apply Update // Apply Update
@ -398,14 +390,14 @@ impl Composable for Usage {
} }
// Things cannot change type // Things cannot change type
(ApplyAccess(_, _), RecordAccess(_, _, _)) (ApplyAccess(_, _), RecordAccess(_, _))
| (ApplyAccess(_, _), RecordUpdate(_, _, _)) | (ApplyAccess(_, _), RecordUpdate(_, _))
| (ApplyUpdate(_, _), RecordAccess(_, _, _)) | (ApplyUpdate(_, _), RecordAccess(_, _))
| (ApplyUpdate(_, _), RecordUpdate(_, _, _)) | (ApplyUpdate(_, _), RecordUpdate(_, _))
| (RecordAccess(_, _, _), ApplyAccess(_, _)) | (RecordAccess(_, _), ApplyAccess(_, _))
| (RecordUpdate(_, _, _), ApplyAccess(_, _)) | (RecordUpdate(_, _), ApplyAccess(_, _))
| (RecordAccess(_, _, _), ApplyUpdate(_, _)) | (RecordAccess(_, _), ApplyUpdate(_, _))
| (RecordUpdate(_, _, _), ApplyUpdate(_, _)) => { | (RecordUpdate(_, _), ApplyUpdate(_, _)) => {
unreachable!("applies cannot turn into records or vice versa!") unreachable!("applies cannot turn into records or vice versa!")
} }
} }
@ -469,7 +461,7 @@ fn correct_overwritten(
} }
} }
RecordUpdate(Container::Record, overwritten.clone(), fa1) RecordUpdate(overwritten.clone(), fa1)
} }
fn correct_overwritten_apply( fn correct_overwritten_apply(
@ -508,12 +500,12 @@ fn make_subtree_shared(usage: &mut Usage) {
*usage = Simple(Shared); *usage = Simple(Shared);
} }
RecordUpdate(_, _, fa) => { RecordUpdate(_, fa) => {
for nested in fa.fields.iter_mut() { for nested in fa.fields.iter_mut() {
make_subtree_shared(nested); make_subtree_shared(nested);
} }
} }
RecordAccess(_, m, fa) => { RecordAccess(m, fa) => {
for nested in fa.fields.iter_mut() { for nested in fa.fields.iter_mut() {
make_subtree_shared(nested); make_subtree_shared(nested);
} }
@ -682,7 +674,7 @@ impl Usage {
for field in access_chain.into_iter().rev() { for field in access_chain.into_iter().rev() {
let mut fa = FieldAccess::default(); let mut fa = FieldAccess::default();
fa.fields.insert(field, accum); fa.fields.insert(field, accum);
accum = Usage::RecordAccess(Container::Record, Mark::Seen, fa); accum = Usage::RecordAccess(Mark::Seen, fa);
} }
accum accum
@ -906,7 +898,7 @@ pub fn annotate_usage(expr: &Expr, usage: &mut VarUsage) {
usage.register_with( usage.register_with(
*symbol, *symbol,
&Usage::RecordUpdate(Container::Record, labels, FieldAccess::default()), &Usage::RecordUpdate(labels, FieldAccess::default()),
); );
} }
Expr::Access { Expr::Access {

86
compiler/uniq/tests/test_usage_analysis.rs
View file

@ -37,7 +37,7 @@ mod test_usage_analysis {
} }
match usage { match usage {
Usage::RecordAccess(_, _, fields) => { Usage::RecordAccess(_, fields) => {
let mut actual: HashMap<Lowercase, Usage> = HashMap::default(); let mut actual: HashMap<Lowercase, Usage> = HashMap::default();
for (k, v) in fields.into_iter() { for (k, v) in fields.into_iter() {
actual.insert(k, v); actual.insert(k, v);
@ -66,7 +66,7 @@ mod test_usage_analysis {
} }
match usage { match usage {
Usage::RecordAccess(_, _, fields) => { Usage::RecordAccess(_, fields) => {
let mut actual: HashMap<Lowercase, Usage> = HashMap::default(); let mut actual: HashMap<Lowercase, Usage> = HashMap::default();
for (k, v) in fields.into_iter() { for (k, v) in fields.into_iter() {
actual.insert(k, v); actual.insert(k, v);
@ -135,14 +135,14 @@ mod test_usage_analysis {
field_access_seq( field_access_seq(
vec![vec!["foo", "bar"], vec!["foo"]], vec![vec!["foo", "bar"], vec!["foo"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Unique, field_access(hashmap![ "bar" => Simple(Shared) ])) "foo" => RecordAccess( Unique, field_access(hashmap![ "bar" => Simple(Shared) ]))
], ],
); );
field_access_seq( field_access_seq(
vec![vec!["foo"], vec!["foo", "bar"]], vec![vec!["foo"], vec!["foo", "bar"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Unique, field_access(hashmap![ "bar" => Simple(Shared) ])) "foo" => RecordAccess( Unique, field_access(hashmap![ "bar" => Simple(Shared) ]))
], ],
); );
} }
@ -151,13 +151,13 @@ mod test_usage_analysis {
field_access_par( field_access_par(
vec![vec!["foo", "bar"], vec!["foo"]], vec![vec!["foo", "bar"], vec!["foo"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Unique, field_access(hashmap![ "bar" => Simple(Unique) ])) "foo" => RecordAccess( Unique, field_access(hashmap![ "bar" => Simple(Unique) ]))
], ],
); );
field_access_par( field_access_par(
vec![vec!["foo"], vec!["foo", "bar"]], vec![vec!["foo"], vec!["foo", "bar"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Unique, field_access(hashmap![ "bar" => Simple(Unique) ])) "foo" => RecordAccess( Unique, field_access(hashmap![ "bar" => Simple(Unique) ]))
], ],
); );
} }
@ -167,13 +167,13 @@ mod test_usage_analysis {
field_access_seq( field_access_seq(
vec![vec!["foo", "bar", "baz"], vec!["foo", "bar"]], vec![vec!["foo", "bar", "baz"], vec!["foo", "bar"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Seen, field_access(hashmap![ "bar" => RecordAccess(Record, Unique, field_access(hashmap![ "baz" => Simple(Shared) ]))])) "foo" => RecordAccess( Seen, field_access(hashmap![ "bar" => RecordAccess( Unique, field_access(hashmap![ "baz" => Simple(Shared) ]))]))
], ],
); );
field_access_seq( field_access_seq(
vec![vec!["foo", "bar"], vec!["foo", "bar", "baz"]], vec![vec!["foo", "bar"], vec!["foo", "bar", "baz"]],
hashmap![ hashmap![
"foo" => RecordAccess(Record, Seen, field_access(hashmap![ "bar" => RecordAccess(Record, Unique, field_access(hashmap![ "baz" => Simple(Shared) ]))])) "foo" => RecordAccess( Seen, field_access(hashmap![ "bar" => RecordAccess( Unique, field_access(hashmap![ "baz" => Simple(Shared) ]))]))
], ],
); );
} }
@ -235,11 +235,7 @@ mod test_usage_analysis {
usage.register_with( usage.register_with(
interns.symbol(home, "rec".into()), interns.symbol(home, "rec".into()),
&RecordAccess( &RecordAccess(Seen, field_access(hashmap![ "foo" => Simple(Unique) ])),
Record,
Seen,
field_access(hashmap![ "foo" => Simple(Unique) ]),
),
); );
usage usage
@ -264,7 +260,6 @@ mod test_usage_analysis {
usage.register_with( usage.register_with(
interns.symbol(home, "rec".into()), interns.symbol(home, "rec".into()),
&RecordUpdate( &RecordUpdate(
Record,
overwritten, overwritten,
field_access(hashmap![ "foo" => Simple(Unique) ]), field_access(hashmap![ "foo" => Simple(Unique) ]),
), ),
@ -313,11 +308,7 @@ mod test_usage_analysis {
usage.register_with( usage.register_with(
interns.symbol(home, "rec".into()), interns.symbol(home, "rec".into()),
&RecordAccess( &RecordAccess(Unique, field_access(hashmap![ "foo" => Simple(Shared) ])),
Record,
Unique,
field_access(hashmap![ "foo" => Simple(Shared) ]),
),
); );
usage usage
@ -351,10 +342,7 @@ mod test_usage_analysis {
]); ]);
usage.register_unique(interns.symbol(home, "p".into())); usage.register_unique(interns.symbol(home, "p".into()));
usage.register_with( usage.register_with(interns.symbol(home, "r".into()), &RecordAccess(Unique, fa));
interns.symbol(home, "r".into()),
&RecordAccess(Record, Unique, fa),
);
usage usage
}, },
@ -379,16 +367,13 @@ mod test_usage_analysis {
let fa = field_access(hashmap![ let fa = field_access(hashmap![
"foo" => "foo" =>
RecordAccess(Record, Seen, field_access(hashmap![ RecordAccess( Seen, field_access(hashmap![
"bar" => Simple(Shared), "bar" => Simple(Shared),
"baz" => Simple(Shared), "baz" => Simple(Shared),
])) ]))
]); ]);
usage.register_with( usage.register_with(interns.symbol(home, "r".into()), &RecordAccess(Unique, fa));
interns.symbol(home, "r".into()),
&RecordAccess(Record, Unique, fa),
);
usage usage
}, },
@ -421,14 +406,14 @@ mod test_usage_analysis {
"x" => Simple(Shared), "x" => Simple(Shared),
]); ]);
usage.register_with(r, &RecordUpdate(Record, overwritten, fa)); usage.register_with(r, &RecordUpdate(overwritten, fa));
let fa = field_access(hashmap![ let fa = field_access(hashmap![
"x" => Simple(Unique), "x" => Simple(Unique),
"y" => Simple(Unique), "y" => Simple(Unique),
]); ]);
usage.register_with(s, &RecordAccess(Record, Seen, fa)); usage.register_with(s, &RecordAccess(Seen, fa));
usage usage
}, },
); );
@ -460,14 +445,14 @@ mod test_usage_analysis {
"x" => Simple(Unique), "x" => Simple(Unique),
]); ]);
usage.register_with(r, &RecordUpdate(Record, overwritten, fa)); usage.register_with(r, &RecordUpdate(overwritten, fa));
let fa = field_access(hashmap![ let fa = field_access(hashmap![
"x" => Simple(Unique), "x" => Simple(Unique),
"y" => Simple(Unique), "y" => Simple(Unique),
]); ]);
usage.register_with(s, &RecordAccess(Record, Seen, fa)); usage.register_with(s, &RecordAccess(Seen, fa));
usage usage
}, },
@ -496,7 +481,7 @@ mod test_usage_analysis {
"y" => Simple(Unique), "y" => Simple(Unique),
]); ]);
usage.register_with(r, &RecordAccess(Record, Seen, fa)); usage.register_with(r, &RecordAccess(Seen, fa));
usage usage
}, },
@ -525,7 +510,7 @@ mod test_usage_analysis {
let overwritten = hashset!["y".into()].into(); let overwritten = hashset!["y".into()].into();
usage.register_with(r, &RecordUpdate(Record, overwritten, fa)); usage.register_with(r, &RecordUpdate(overwritten, fa));
usage usage
}, },
@ -547,7 +532,6 @@ mod test_usage_analysis {
let mut usage = VarUsage::default(); let mut usage = VarUsage::default();
let access = RecordAccess( let access = RecordAccess(
Record,
Seen, Seen,
field_access(hashmap![ field_access(hashmap![
"x" => Simple(Unique), "x" => Simple(Unique),
@ -599,16 +583,8 @@ mod test_usage_analysis {
let mut usage = VarUsage::default(); let mut usage = VarUsage::default();
let home = test_home(); let home = test_home();
let access_r = RecordAccess( let access_r = RecordAccess(Seen, field_access(hashmap![ "y" => Simple(Unique) ]));
Record, let access_s = RecordAccess(Seen, field_access(hashmap![ "x" => Simple(Shared) ]));
Seen,
field_access(hashmap![ "y" => Simple(Unique) ]),
);
let access_s = RecordAccess(
Record,
Seen,
field_access(hashmap![ "x" => Simple(Shared) ]),
);
let r = interns.symbol(home, "r".into()); let r = interns.symbol(home, "r".into());
let s = interns.symbol(home, "s".into()); let s = interns.symbol(home, "s".into());
@ -640,16 +616,8 @@ mod test_usage_analysis {
let mut usage = VarUsage::default(); let mut usage = VarUsage::default();
let home = test_home(); let home = test_home();
let access_r = RecordAccess( let access_r = RecordAccess(Seen, field_access(hashmap![ "x" => Simple(Unique) ]));
Record, let access_s = RecordAccess(Seen, field_access(hashmap![ "x" => Simple(Shared) ]));
Seen,
field_access(hashmap![ "x" => Simple(Unique) ]),
);
let access_s = RecordAccess(
Record,
Seen,
field_access(hashmap![ "x" => Simple(Shared) ]),
);
let r = interns.symbol(home, "r".into()); let r = interns.symbol(home, "r".into());
let s = interns.symbol(home, "s".into()); let s = interns.symbol(home, "s".into());
@ -681,14 +649,10 @@ mod test_usage_analysis {
let home = test_home(); let home = test_home();
let overwritten = hashset!["y".into()].into(); let overwritten = hashset!["y".into()].into();
let access_r = RecordUpdate( let access_r =
Record, RecordUpdate(overwritten, field_access(hashmap![ "x" => Simple(Shared) ]));
overwritten,
field_access(hashmap![ "x" => Simple(Shared) ]),
);
let access_s = RecordAccess( let access_s = RecordAccess(
Record,
Unique, Unique,
field_access(hashmap![ field_access(hashmap![
"x" => Simple(Shared), "x" => Simple(Shared),