employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: ir::asg::section: Reduce fields 

This is intended to represent the sections written to the final xmle file,
and there was unnecessary complexity in separating everything.

By reducing this IR further, we can begin to constrain its types to
eliminate some of the runtime panics and error checking we have/had in the
writer.
main
Mike Gerwitz 2021-10-11 09:07:48 -04:00
parent f70f5653b2
commit de62a2acbc
3 changed files with 30 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
tamer/src/ir/asg/base.rs
View File

@ -299,18 +299,18 @@ where
match ident.kind() {
Some(kind) => match kind {
IdentKind::Meta => deps.meta.push_body(ident),
IdentKind::Worksheet => deps.worksheet.push_body(ident),
IdentKind::Param(_, _) => deps.params.push_body(ident),
IdentKind::Type(_) => deps.types.push_body(ident),
IdentKind::Func(_, _) => deps.funcs.push_body(ident),
IdentKind::Meta
| IdentKind::Worksheet
| IdentKind::Param(_, _)
| IdentKind::Type(_)
| IdentKind::Func(_, _)
| IdentKind::Const(_, _) => deps.st.push_body(ident),
IdentKind::MapHead
| IdentKind::Map
| IdentKind::MapTail => deps.map.push_body(ident),
IdentKind::RetMapHead
| IdentKind::RetMap
| IdentKind::RetMapTail => deps.retmap.push_body(ident),
IdentKind::Const(_, _) => deps.consts.push_body(ident),
_ => deps.rater.push_body(ident),
},
None => {
@ -888,11 +888,9 @@ mod test {
fn graph_sort() -> SortableAsgResult<(), u16> {
let mut sut = Sut::new();
let mut meta = vec![];
let mut worksheet = vec![];
let mut st = vec![];
let mut map = vec![];
let mut retmap = vec![];
let mut consts = vec![];
let base = "sym1".intern();
let base_node = sut
@ -900,9 +898,9 @@ mod test {
.unwrap();
add_syms!(sut, base, {
meta <- meta1: IdentKind::Meta,
worksheet <- work1: IdentKind::Worksheet,
consts <- const1: IdentKind::Const(Dim::from_u8(0), DataType::Float),
st <- meta1: IdentKind::Meta,
st <- work1: IdentKind::Worksheet,
st <- const1: IdentKind::Const(Dim::from_u8(0), DataType::Float),
map <- map1: IdentKind::MapHead,
map <- map2: IdentKind::Map,
map <- map3: IdentKind::MapTail,
@ -913,22 +911,20 @@ mod test {
retmap <- retmap5: IdentKind::RetMap,
map <- map4: IdentKind::MapHead,
map <- map5: IdentKind::Map,
meta <- meta2: IdentKind::Meta,
worksheet <- work2: IdentKind::Worksheet,
st <- meta2: IdentKind::Meta,
st <- work2: IdentKind::Worksheet,
map <- map6: IdentKind::MapTail,
retmap <- retmap6: IdentKind::RetMapHead,
consts <- const2: IdentKind::Const(Dim::from_u8(2), DataType::Float),
st <- const2: IdentKind::Const(Dim::from_u8(2), DataType::Float),
});
map.push(base);
let sections = sut.sort(&vec![base_node])?;
assert_section_sym!(sections.meta, meta);
assert_section_sym!(sections.worksheet, worksheet);
assert_section_sym!(sections.st, st);
assert_section_sym!(sections.map, map);
assert_section_sym!(sections.retmap, retmap);
assert_section_sym!(sections.consts, consts);
Ok(())
}

58
tamer/src/ir/asg/section.rs
View File

@ -110,6 +110,11 @@ impl<'a, T> Iterator for SectionIter<'a, T> {
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|x| *x)
}
fn size_hint(&self) -> (usize, Option<usize>) {
let (low, high) = self.0.size_hint();
(low, high.map(|x| x + 2))
}
}
/// ASG objects organized into logical sections.
@ -121,12 +126,7 @@ impl<'a, T> Iterator for SectionIter<'a, T> {
pub struct Sections<'a, T> {
pub map: Section<'a, T>,
pub retmap: Section<'a, T>,
pub meta: Section<'a, T>,
pub worksheet: Section<'a, T>,
pub params: Section<'a, T>,
pub types: Section<'a, T>,
pub funcs: Section<'a, T>,
pub consts: Section<'a, T>,
pub st: Section<'a, T>,
pub rater: Section<'a, T>,
}
@ -137,12 +137,7 @@ impl<'a, T: IdentObjectData> Sections<'a, T> {
Self {
map: Section::new(),
retmap: Section::new(),
meta: Section::new(),
worksheet: Section::new(),
params: Section::new(),
types: Section::new(),
funcs: Section::new(),
consts: Section::new(),
st: Section::new(),
rater: Section::new(),
}
}
@ -163,12 +158,7 @@ impl<'a, T: IdentObjectData> Sections<'a, T> {
self.map
.iter()
.chain(self.retmap.iter())
.chain(self.meta.iter())
.chain(self.worksheet.iter())
.chain(self.params.iter())
.chain(self.types.iter())
.chain(self.funcs.iter())
.chain(self.consts.iter())
.chain(self.st.iter())
.chain(self.rater.iter()),
))
}
@ -185,15 +175,7 @@ impl<'a, T: IdentObjectData> Sections<'a, T> {
/// they may change or be combined in the future.
#[inline]
pub fn iter_static(&self) -> SectionsIter<T> {
SectionsIter(SectionsIterType::Static(
self.meta
.iter()
.chain(self.worksheet.iter())
.chain(self.params.iter())
.chain(self.types.iter())
.chain(self.funcs.iter())
.chain(self.consts.iter()),
))
SectionsIter(SectionsIterType::Single(self.st.iter()))
}
/// Construct an iterator over the map section.
@ -235,16 +217,11 @@ impl<'a, T: IdentObjectData> Sections<'a, T> {
type SIter<'a, T> = SectionIter<'a, T>;
type CSIter1<'a, T, L> = Chain<L, SIter<'a, T>>;
type CSIter2<'a, T, L> = CSIter1<'a, T, CSIter1<'a, T, L>>;
type CSIter4<'a, T, L> = CSIter2<'a, T, CSIter2<'a, T, L>>;
type CSIter8<'a, T, L> = CSIter4<'a, T, CSIter4<'a, T, L>>;
type SIter6<'a, T> = CSIter4<'a, T, CSIter1<'a, T, SIter<'a, T>>>;
type SIter9<'a, T> = CSIter8<'a, T, SIter<'a, T>>;
type SIter4<'a, T> = CSIter2<'a, T, CSIter1<'a, T, SIter<'a, T>>>;
/// Types of iterators encapsulated by [`SectionsIter`].
enum SectionsIterType<'a, T> {
All(SIter9<'a, T>),
Static(SIter6<'a, T>),
All(SIter4<'a, T>),
Single(SIter<'a, T>),
}
@ -262,7 +239,6 @@ impl<'a, T> Iterator for SectionsIter<'a, T> {
fn next(&mut self) -> Option<Self::Item> {
match &mut self.0 {
SectionsIterType::All(inner) => inner.next(),
SectionsIterType::Static(inner) => inner.next(),
SectionsIterType::Single(inner) => inner.next(),
}
}
@ -271,7 +247,6 @@ impl<'a, T> Iterator for SectionsIter<'a, T> {
fn size_hint(&self) -> (usize, Option<usize>) {
match &self.0 {
SectionsIterType::All(inner) => inner.size_hint(),
SectionsIterType::Static(inner) => inner.size_hint(),
SectionsIterType::Single(inner) => inner.size_hint(),
}
}
@ -382,7 +357,7 @@ mod test {
fn sections_iter_all() {
let mut sections = Sections::new();
let objs = (0..=10)
let objs = (0..=5)
.map(|i| IdentObject::Missing(i.to_string().into()))
.collect::<Vec<_>>();
@ -390,13 +365,8 @@ mod test {
sections.map.body.push(&objs[1]);
sections.map.set_tail(&objs[2]);
sections.retmap.body.push(&objs[3]);
sections.meta.body.push(&objs[4]);
sections.worksheet.body.push(&objs[5]);
sections.params.body.push(&objs[6]);
sections.types.body.push(&objs[7]);
sections.funcs.body.push(&objs[8]);
sections.consts.body.push(&objs[9]);
sections.rater.body.push(&objs[10]);
sections.st.body.push(&objs[4]);
sections.rater.body.push(&objs[5]);
assert_eq!(
sections.iter_all().collect::<Vec<_>>(),

4
tamer/src/obj/xmle/xir/test.rs
View File

@ -178,7 +178,7 @@ fn test_writes_deps() -> TestResult {
),
];
objs.iter().for_each(|x| sections.consts.push_body(x));
objs.iter().for_each(|x| sections.st.push_body(x));
let mut iter = parser_from(
lower_iter(&sections, "pkg".intern(), relroot)
@ -468,5 +468,5 @@ macro_rules! test_exec_sec {
test_exec_sec!(test_map_exec, QN_L_MAP_EXEC, map);
test_exec_sec!(test_retmap_exec, QN_L_RETMAP_EXEC, retmap);
test_exec_sec!(test_static, QN_L_STATIC, params); // just pick a static
test_exec_sec!(test_static, QN_L_STATIC, st);
test_exec_sec!(test_exec, QN_L_EXEC, rater);