employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: asg::Asg::lookup: SymbolId=>SPair 

This seems to have been an oversight from when I recently introduced SPairs
to ASG; I noticed it while working on another change and receiving back a
`DUMMY_SPAN`.

DEV-13597
main
Mike Gerwitz 2023-01-17 14:42:43 -05:00
parent 554bb81a63
commit 378fe3db66
4 changed files with 55 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tamer/benches/asg.rs
View File

@ -147,7 +147,7 @@ mod base {
bench.iter(|| {
xs.iter()
.map(|sym| sut.lookup(sym.symbol()).unwrap())
.map(|sym| sut.lookup(*sym).unwrap())
.for_each(drop);
});
}

81
tamer/src/asg/air/test.rs
View File

@ -32,35 +32,34 @@ type Sut = AirAggregate;
#[test]
fn ident_decl() {
let sym = "foo".into();
let id = SPair("foo".into(), S1);
let kind = IdentKind::Tpl;
let src = Source {
src: Some("test/decl".into()),
..Default::default()
};
let toks = vec![Air::IdentDecl(SPair(sym, S1), kind.clone(), src.clone())]
.into_iter();
let toks = vec![Air::IdentDecl(id, kind.clone(), src.clone())].into_iter();
let mut sut = Sut::parse(toks);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next());
let asg = sut.finalize().unwrap().into_context();
let ident_node =
asg.lookup(sym).expect("identifier was not added to graph");
let ident_node = asg.lookup(id).expect("identifier was not added to graph");
let ident = asg.get(ident_node).unwrap();
assert_eq!(
Ok(ident),
Ident::declare(SPair(sym, S1))
Ident::declare(id)
.resolve(S1, kind.clone(), src.clone())
.as_ref(),
);
// Re-instantiate the parser and test an error by attempting to
// redeclare the same identifier.
let bad_toks = vec![Air::IdentDecl(SPair(sym, S2), kind, src)].into_iter();
let bad_toks =
vec![Air::IdentDecl(SPair(id.symbol(), S2), kind, src)].into_iter();
let mut sut = Sut::parse_with_context(bad_toks, asg);
assert_matches!(
@ -71,42 +70,38 @@ fn ident_decl() {
#[test]
fn ident_extern_decl() {
let sym = "foo".into();
let id = SPair("foo".into(), S1);
let kind = IdentKind::Tpl;
let src = Source {
src: Some("test/decl-extern".into()),
..Default::default()
};
let toks = vec![Air::IdentExternDecl(
SPair(sym, S1),
kind.clone(),
src.clone(),
)]
.into_iter();
let toks =
vec![Air::IdentExternDecl(id, kind.clone(), src.clone())].into_iter();
let mut sut = Sut::parse(toks);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next());
let asg = sut.finalize().unwrap().into_context();
let ident_node =
asg.lookup(sym).expect("identifier was not added to graph");
let ident_node = asg.lookup(id).expect("identifier was not added to graph");
let ident = asg.get(ident_node).unwrap();
assert_eq!(
Ok(ident),
Ident::declare(SPair(sym, S1))
.extern_(S1, kind, src.clone())
.as_ref(),
Ident::declare(id).extern_(S1, kind, src.clone()).as_ref(),
);
// Re-instantiate the parser and test an error by attempting to
// redeclare with a different kind.
let different_kind = IdentKind::Meta;
let bad_toks =
vec![Air::IdentExternDecl(SPair(sym, S2), different_kind, src)]
.into_iter();
let bad_toks = vec![Air::IdentExternDecl(
SPair(id.symbol(), S2),
different_kind,
src,
)]
.into_iter();
let mut sut = Sut::parse_with_context(bad_toks, asg);
assert_matches!(
@ -117,20 +112,17 @@ fn ident_extern_decl() {
#[test]
fn ident_dep() {
let ident = "foo".into();
let dep = "dep".into();
let id = SPair("foo".into(), S1);
let dep = SPair("dep".into(), S2);
let toks =
vec![Air::IdentDep(SPair(ident, S1), SPair(dep, S2))].into_iter();
let toks = vec![Air::IdentDep(id, dep)].into_iter();
let mut sut = Sut::parse(toks);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next());
let asg = sut.finalize().unwrap().into_context();
let ident_node = asg
.lookup(ident)
.expect("identifier was not added to graph");
let ident_node = asg.lookup(id).expect("identifier was not added to graph");
let dep_node = asg.lookup(dep).expect("dep was not added to graph");
assert!(asg.has_dep(ident_node, dep_node));
@ -138,7 +130,7 @@ fn ident_dep() {
#[test]
fn ident_fragment() {
let sym = "frag".into();
let id = SPair("frag".into(), S1);
let kind = IdentKind::Tpl;
let src = Source {
src: Some("test/frag".into()),
@ -149,8 +141,8 @@ fn ident_fragment() {
let toks = vec![
// Identifier must be declared before it can be given a
// fragment.
Air::IdentDecl(SPair(sym, S1), kind.clone(), src.clone()),
Air::IdentFragment(SPair(sym, S1), frag),
Air::IdentDecl(id, kind.clone(), src.clone()),
Air::IdentFragment(id, frag),
]
.into_iter();
@ -161,13 +153,12 @@ fn ident_fragment() {
let asg = sut.finalize().unwrap().into_context();
let ident_node =
asg.lookup(sym).expect("identifier was not added to graph");
let ident_node = asg.lookup(id).expect("identifier was not added to graph");
let ident = asg.get(ident_node).unwrap();
assert_eq!(
Ok(ident),
Ident::declare(SPair(sym, S1))
Ident::declare(id)
.resolve(S1, kind.clone(), src.clone())
.and_then(|resolved| resolved.set_fragment(frag))
.as_ref(),
@ -175,7 +166,7 @@ fn ident_fragment() {
// Re-instantiate the parser and test an error by attempting to
// re-set the fragment.
let bad_toks = vec![Air::IdentFragment(SPair(sym, S1), frag)].into_iter();
let bad_toks = vec![Air::IdentFragment(id, frag)].into_iter();
let mut sut = Sut::parse_with_context(bad_toks, asg);
assert_matches!(
@ -188,9 +179,9 @@ fn ident_fragment() {
// `Ident::Missing`.
#[test]
fn ident_root_missing() {
let sym = "toroot".into();
let id = SPair("toroot".into(), S1);
let toks = vec![Air::IdentRoot(SPair(sym, S1))].into_iter();
let toks = vec![Air::IdentRoot(id)].into_iter();
let mut sut = Sut::parse(toks);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next());
@ -198,13 +189,13 @@ fn ident_root_missing() {
let asg = sut.finalize().unwrap().into_context();
let ident_node = asg
.lookup(sym)
.lookup(id)
.expect("identifier was not added to the graph");
let ident = asg.get(ident_node).unwrap();
// The identifier did not previously exist,
// and so a missing node is created as a placeholder.
assert_eq!(&Ident::Missing(SPair(sym, S1)), ident);
assert_eq!(&Ident::Missing(id), ident);
// And that missing identifier should be rooted.
assert!(asg.is_rooted(ident_node));
@ -212,7 +203,7 @@ fn ident_root_missing() {
#[test]
fn ident_root_existing() {
let sym = "toroot".into();
let id = SPair("toroot".into(), S1);
let kind = IdentKind::Tpl;
let src = Source {
src: Some("test/root-existing".into()),
@ -224,8 +215,8 @@ fn ident_root_existing() {
assert!(!kind.is_auto_root());
let toks = vec![
Air::IdentDecl(SPair(sym, S1), kind.clone(), src.clone()),
Air::IdentRoot(SPair(sym, S2)),
Air::IdentDecl(id, kind.clone(), src.clone()),
Air::IdentRoot(SPair(id.symbol(), S2)),
]
.into_iter();
@ -237,14 +228,14 @@ fn ident_root_existing() {
let asg = sut.finalize().unwrap().into_context();
let ident_node = asg
.lookup(sym)
.lookup(id)
.expect("identifier was not added to the graph");
let ident = asg.get(ident_node).unwrap();
// The previously-declared identifier...
assert_eq!(
Ok(ident),
Ident::declare(SPair(sym, S1))
Ident::declare(id)
.resolve(S1, kind.clone(), src.clone())
.as_ref()
);

21
tamer/src/asg/graph.rs
View File

@ -31,7 +31,6 @@ use crate::fmt::{DisplayWrapper, TtQuote};
use crate::global;
use crate::parse::util::SPair;
use crate::parse::Token;
use crate::span::UNKNOWN_SPAN;
use crate::sym::SymbolId;
use petgraph::{
graph::{DiGraph, Graph, NodeIndex},
@ -193,12 +192,10 @@ impl Asg {
&mut self,
ident: SPair,
) -> ObjectIndex<Ident> {
let sym = ident.symbol();
self.lookup(sym).unwrap_or_else(|| {
self.lookup(ident).unwrap_or_else(|| {
let index = self.graph.add_node(Ident::declare(ident).into());
self.index_identifier(sym, index);
self.index_identifier(ident.symbol(), index);
ObjectIndex::new(index, ident.span())
})
}
@ -501,7 +498,7 @@ impl Asg {
&self,
ident: SPair,
) -> Option<ObjectIndex<O>> {
self.lookup(ident.symbol())
self.lookup(ident)
.and_then(|identi| {
self.graph
.neighbors_directed(identi.into(), Direction::Outgoing)
@ -613,13 +610,13 @@ impl Asg {
/// graph---for
/// that, see [`Asg::get`].
#[inline]
pub fn lookup(&self, name: SymbolId) -> Option<ObjectIndex<Ident>> {
let i = name.as_usize();
pub fn lookup(&self, id: SPair) -> Option<ObjectIndex<Ident>> {
let i = id.symbol().as_usize();
self.index
.get(i)
.filter(|ni| ni.index() > 0)
.map(|ni| ObjectIndex::new(*ni, UNKNOWN_SPAN))
.map(|ni| ObjectIndex::new(*ni, id.span()))
}
/// Declare that `dep` is a dependency of `ident`.
@ -819,9 +816,9 @@ mod test {
fn lookup_by_symbol() -> AsgResult<()> {
let mut sut = Sut::new();
let sym = "lookup".into();
let id = SPair("lookup".into(), S1);
let node = sut.declare(
SPair(sym, S1),
id,
IdentKind::Meta,
Source {
generated: true,
@ -829,7 +826,7 @@ mod test {
},
)?;
assert_eq!(Some(node), sut.lookup(sym));
assert_eq!(Some(node), sut.lookup(id));
Ok(())
}

23
tamer/src/ld/xmle/lower.rs
View File

@ -95,7 +95,7 @@ where
let sym = name.into();
depgraph
.lookup(sym)
.lookup(SPair(sym, UNKNOWN_SPAN))
.and_then(|id| depgraph.get(id))
.unwrap_or_else(|| {
panic!("missing internal identifier: {}", sym.lookup_str())
@ -397,23 +397,18 @@ mod test {
sections.pushed,
vec![
// Static head
asg.lookup(st::L_MAP_UUUHEAD.into())
.and_then(|id| asg.get_ident(id)),
asg.lookup(st::L_RETMAP_UUUHEAD.into())
.and_then(|id| asg.get_ident(id)),
get_ident(&asg, st::L_MAP_UUUHEAD),
get_ident(&asg, st::L_RETMAP_UUUHEAD),
// Post-order
asg.get_ident(adepdep),
asg.get_ident(adep),
asg.get_ident(a),
asg.get_ident(adepdep).unwrap(),
asg.get_ident(adep).unwrap(),
asg.get_ident(a).unwrap(),
// Static tail
asg.lookup(st::L_MAP_UUUTAIL.into())
.and_then(|id| asg.get_ident(id)),
asg.lookup(st::L_RETMAP_UUUTAIL.into())
.and_then(|id| asg.get_ident(id)),
get_ident(&asg, st::L_MAP_UUUTAIL),
get_ident(&asg, st::L_RETMAP_UUUTAIL),
]
.into_iter()
.collect::<Option<Vec<_>>>()
.unwrap()
.collect::<Vec<_>>()
);
Ok(())