employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: obj::xmlo: More concise identifiers 

This follows conventions of other, more recently written, systems.

DEV-13162
main
Mike Gerwitz 2023-04-20 16:38:16 -04:00
parent e13817c203
commit dd47fc564d
3 changed files with 139 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
tamer/src/obj/xmlo/air.rs
View File

@ -35,7 +35,7 @@ use crate::{
sym::SymbolId,
};
use super::XmloToken;
use super::XmloToken::{self, *};
/// Persistent `xmlo` lowering context to be shared among all `xmlo` files.
///
@ -113,7 +113,7 @@ impl ParseState for XmloToAir {
use XmloToAir::*;
match (self, tok) {
(PackageExpected, XmloToken::PkgName(name)) => {
(PackageExpected, PkgName(name)) => {
if ctx.is_first() {
ctx.prog_name = Some(name.symbol());
}
@ -121,7 +121,7 @@ impl ParseState for XmloToAir {
Transition(Package(name)).incomplete()
}
(st @ Package(..), XmloToken::PkgRootPath(relroot)) => {
(st @ Package(..), PkgRootPath(relroot)) => {
if ctx.is_first() {
ctx.relroot = Some(relroot.symbol());
}
@ -135,7 +135,7 @@ impl ParseState for XmloToAir {
// definition is encountered later within the same file.
// TODO: Let's remove the need for this special root handling
// here.
(Package(name), XmloToken::PkgEligClassYields(pkg_elig)) => {
(Package(name), PkgEligClassYields(pkg_elig)) => {
// The span for this is a bit awkward,
// given that rooting is automatic,
// but it it should never have to be utilized in
@ -143,27 +143,23 @@ impl ParseState for XmloToAir {
Transition(Package(name)).ok(Air::IdentRoot(pkg_elig))
}
(
st @ (PackageExpected | Package(..)),
XmloToken::PkgProgramFlag(_),
) => {
(st @ (PackageExpected | Package(..)), PkgProgramFlag(_)) => {
// TODO: Unused
Transition(st).incomplete()
}
(
Package(pkg_name) | SymDep(pkg_name, ..),
XmloToken::SymDepStart(sym),
) => Transition(SymDep(pkg_name, sym)).incomplete(),
(Package(pkg_name) | SymDep(pkg_name, ..), SymDepStart(sym)) => {
Transition(SymDep(pkg_name, sym)).incomplete()
}
(SymDep(pkg_name, sym), XmloToken::Symbol(dep_sym)) => {
(SymDep(pkg_name, sym), Symbol(dep_sym)) => {
Transition(SymDep(pkg_name, sym))
.ok(Air::IdentDep(sym, dep_sym))
}
(
Package(pkg_name),
XmloToken::SymDecl(
SymDecl(
_name,
SymAttrs {
src: Some(sym_src), ..
@ -174,7 +170,7 @@ impl ParseState for XmloToAir {
Transition(Package(pkg_name)).incomplete()
}
(Package(pkg_name), XmloToken::SymDecl(name, attrs)) => {
(Package(pkg_name), SymDecl(name, attrs)) => {
let extern_ = attrs.extern_;
// TODO: This attr/source separation is a mess,
@ -209,16 +205,13 @@ impl ParseState for XmloToAir {
.transition(Package(pkg_name))
}
(
Package(pkg_name) | SymDep(pkg_name, _),
XmloToken::Fragment(name, text),
) => {
(Package(pkg_name) | SymDep(pkg_name, _), Fragment(name, text)) => {
Transition(Package(pkg_name)).ok(Air::IdentFragment(name, text))
}
// We don't need to read any further than the end of the
// header (symtable, sym-deps, fragments).
(Package(..) | SymDep(..), XmloToken::Eoh(span)) => {
(Package(..) | SymDep(..), Eoh(span)) => {
// It's important to set this _after_ we're done processing,
// otherwise our `first` checks above will be inaccurate.
ctx.first = false;

144
tamer/src/obj/xmlo/air/test.rs
View File

@ -29,23 +29,30 @@ use crate::{
type Sut = XmloToAir;
use Parsed::{Incomplete, Object as O};
#[test]
fn data_from_package_event() {
let name = "name".into();
let relroot = "some/path".into();
let toks = vec![
XmloToken::PkgName(SPair(name, S1)),
XmloToken::PkgRootPath(SPair(relroot, S2)),
XmloToken::Eoh(S3),
PkgName(SPair(name, S1)),
PkgRootPath(SPair(relroot, S2)),
Eoh(S3),
]
.into_iter();
let mut sut = Sut::parse(toks);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // PkgName
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // PkgRootPath
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // Eoh
assert_eq!(
Ok(vec![
Incomplete, // PkgName
Incomplete, // PkgRootPath
Incomplete, // Eoh
]),
sut.by_ref().collect(),
);
let ctx = sut.finalize().unwrap().into_context();
@ -59,16 +66,16 @@ fn adds_elig_as_root() {
let elig_sym = "elig".into();
let toks = vec![
XmloToken::PkgName(SPair(name, S1)),
XmloToken::PkgEligClassYields(SPair(elig_sym, S2)),
XmloToken::Eoh(S3),
PkgName(SPair(name, S1)),
PkgEligClassYields(SPair(elig_sym, S2)),
Eoh(S3),
];
assert_eq!(
Ok(vec![
Parsed::Incomplete, // PkgName
Parsed::Object(Air::IdentRoot(SPair(elig_sym, S2))),
Parsed::Incomplete, // Eoh
Incomplete, // PkgName
O(Air::IdentRoot(SPair(elig_sym, S2))),
Incomplete, // Eoh
]),
Sut::parse(toks.into_iter()).collect(),
);
@ -81,26 +88,20 @@ fn adds_sym_deps() {
let sym_to2 = "to2".into();
let toks = vec![
XmloToken::PkgName(SPair("name".into(), S1)),
XmloToken::SymDepStart(SPair(sym_from, S2)),
XmloToken::Symbol(SPair(sym_to1, S3)),
XmloToken::Symbol(SPair(sym_to2, S4)),
XmloToken::Eoh(S1),
PkgName(SPair("name".into(), S1)),
SymDepStart(SPair(sym_from, S2)),
Symbol(SPair(sym_to1, S3)),
Symbol(SPair(sym_to2, S4)),
Eoh(S1),
];
assert_eq!(
Ok(vec![
Parsed::Incomplete, // PkgName
Parsed::Incomplete, // SymDepStart
Parsed::Object(Air::IdentDep(
SPair(sym_from, S2),
SPair(sym_to1, S3)
)),
Parsed::Object(Air::IdentDep(
SPair(sym_from, S2),
SPair(sym_to2, S4)
)),
Parsed::Incomplete, // Eoh
Incomplete, // PkgName
Incomplete, // SymDepStart
O(Air::IdentDep(SPair(sym_from, S2), SPair(sym_to1, S3))),
O(Air::IdentDep(SPair(sym_from, S2), SPair(sym_to2, S4))),
Incomplete, // Eoh
]),
Sut::parse(toks.into_iter()).collect(),
);
@ -113,30 +114,35 @@ fn sym_decl_with_src_not_added_and_populates_found() {
let src_b = "src_b".into();
let toks = vec![
XmloToken::PkgName(SPair("name".into(), S1)),
XmloToken::SymDecl(
PkgName(SPair("name".into(), S1)),
SymDecl(
SPair(sym, S2),
SymAttrs {
src: Some(src_a),
..Default::default()
},
),
XmloToken::SymDecl(
SymDecl(
SPair(sym, S3),
SymAttrs {
src: Some(src_b),
..Default::default()
},
),
XmloToken::Eoh(S1),
Eoh(S1),
];
let mut sut = Sut::parse(toks.into_iter());
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // PkgName
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // SymDecl (@src)
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // SymDecl (@src)
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // Eoh
assert_eq!(
Ok(vec![
Incomplete, // PkgName
Incomplete, // SymDecl (@src)
Incomplete, // SymDecl (@src)
Incomplete, // Eoh
]),
sut.by_ref().collect(),
);
let ctx = sut.finalize().unwrap().into_context();
let mut founds = ctx.found.unwrap().into_iter().collect::<Vec<_>>();
@ -157,8 +163,8 @@ fn sym_decl_added_to_graph() {
let pkg_name = "pkg name".into();
let toks = vec![
XmloToken::PkgName(SPair("name".into(), S1)),
XmloToken::SymDecl(
PkgName(SPair("name".into(), S1)),
SymDecl(
SPair(sym_extern, S1),
SymAttrs {
pkg_name: Some(pkg_name),
@ -167,7 +173,7 @@ fn sym_decl_added_to_graph() {
..Default::default()
},
),
XmloToken::SymDecl(
SymDecl(
SPair(sym_non_extern, S2),
SymAttrs {
pkg_name: Some(pkg_name),
@ -175,7 +181,7 @@ fn sym_decl_added_to_graph() {
..Default::default()
},
),
XmloToken::SymDecl(
SymDecl(
SPair(sym_map, S3),
SymAttrs {
pkg_name: Some(pkg_name),
@ -183,7 +189,7 @@ fn sym_decl_added_to_graph() {
..Default::default()
},
),
XmloToken::SymDecl(
SymDecl(
SPair(sym_retmap, S4),
SymAttrs {
pkg_name: Some(pkg_name),
@ -191,16 +197,16 @@ fn sym_decl_added_to_graph() {
..Default::default()
},
),
XmloToken::Eoh(S1),
Eoh(S1),
];
let mut sut = Sut::parse(toks.into_iter());
// Note that each of these will have their package names cleared
// since this is considered to be the first package encountered.
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // PkgName
assert_eq!(Some(Ok(Incomplete)), sut.next()); // PkgName
assert_eq!(
Some(Ok(Parsed::Object(Air::IdentExternDecl(
Some(Ok(O(Air::IdentExternDecl(
SPair(sym_extern, S1),
IdentKind::Meta,
Source {
@ -211,7 +217,7 @@ fn sym_decl_added_to_graph() {
sut.next(),
);
assert_eq!(
Some(Ok(Parsed::Object(Air::IdentDecl(
Some(Ok(O(Air::IdentDecl(
SPair(sym_non_extern, S2),
IdentKind::Meta,
Source {
@ -222,7 +228,7 @@ fn sym_decl_added_to_graph() {
sut.next(),
);
assert_eq!(
Some(Ok(Parsed::Object(Air::IdentDecl(
Some(Ok(O(Air::IdentDecl(
SPair(sym_map, S3),
IdentKind::Map,
Source {
@ -233,7 +239,7 @@ fn sym_decl_added_to_graph() {
sut.next(),
);
assert_eq!(
Some(Ok(Parsed::Object(Air::IdentDecl(
Some(Ok(O(Air::IdentDecl(
SPair(sym_retmap, S4),
IdentKind::RetMap,
Source {
@ -243,7 +249,7 @@ fn sym_decl_added_to_graph() {
)))),
sut.next(),
);
assert_eq!(Some(Ok(Parsed::Incomplete)), sut.next()); // Eoh
assert_eq!(Some(Ok(Incomplete)), sut.next()); // Eoh
let ctx = sut.finalize().unwrap().into_context();
@ -268,8 +274,8 @@ fn sym_decl_pkg_name_retained_if_not_first() {
};
let toks = vec![
XmloToken::PkgName(SPair(pkg_name, S1)),
XmloToken::SymDecl(
PkgName(SPair(pkg_name, S1)),
SymDecl(
SPair(sym, S2),
SymAttrs {
pkg_name: Some(pkg_name),
@ -277,13 +283,13 @@ fn sym_decl_pkg_name_retained_if_not_first() {
..Default::default()
},
),
XmloToken::Eoh(S1),
Eoh(S1),
];
assert_eq!(
Ok(vec![
Parsed::Incomplete, // PkgName
Parsed::Object(Air::IdentDecl(
Incomplete, // PkgName
O(Air::IdentDecl(
SPair(sym, S2),
IdentKind::Meta,
Source {
@ -291,7 +297,7 @@ fn sym_decl_pkg_name_retained_if_not_first() {
..Default::default()
}
)),
Parsed::Incomplete, // Eoh
Incomplete, // Eoh
]),
Sut::parse_with_context(toks.into_iter(), ctx).collect(),
);
@ -310,8 +316,8 @@ fn sym_decl_pkg_name_set_if_empty_and_not_first() {
};
let toks = vec![
XmloToken::PkgName(SPair(pkg_name, S1)),
XmloToken::SymDecl(
PkgName(SPair(pkg_name, S1)),
SymDecl(
SPair(sym, S2),
SymAttrs {
// No name
@ -319,13 +325,13 @@ fn sym_decl_pkg_name_set_if_empty_and_not_first() {
..Default::default()
},
),
XmloToken::Eoh(S1),
Eoh(S1),
];
assert_eq!(
Ok(vec![
Parsed::Incomplete, // PkgName
Parsed::Object(Air::IdentDecl(
Incomplete, // PkgName
O(Air::IdentDecl(
SPair(sym, S2),
IdentKind::Meta,
Source {
@ -333,7 +339,7 @@ fn sym_decl_pkg_name_set_if_empty_and_not_first() {
..Default::default()
},
)),
Parsed::Incomplete, // Eoh
Incomplete, // Eoh
]),
Sut::parse_with_context(toks.into_iter(), ctx).collect(),
);
@ -345,9 +351,9 @@ fn ident_kind_conversion_error_propagates() {
let bad_attrs = SymAttrs::default();
let toks = vec![
XmloToken::PkgName(SPair("name".into(), S1)),
XmloToken::SymDecl(SPair(sym, S2), bad_attrs),
XmloToken::Eoh(S1),
PkgName(SPair("name".into(), S1)),
SymDecl(SPair(sym, S2), bad_attrs),
Eoh(S1),
];
Sut::parse(toks.into_iter())
@ -361,16 +367,16 @@ fn sets_fragment() {
let frag = FragmentText::from("foo");
let toks = vec![
XmloToken::PkgName(SPair("name".into(), S1)),
XmloToken::Fragment(SPair(sym, S2), frag.clone()),
XmloToken::Eoh(S1),
PkgName(SPair("name".into(), S1)),
Fragment(SPair(sym, S2), frag.clone()),
Eoh(S1),
];
assert_eq!(
Ok(vec![
Parsed::Incomplete, // PkgName
Parsed::Object(Air::IdentFragment(SPair(sym, S2), frag)),
Parsed::Incomplete, // Eoh
Incomplete, // PkgName
O(Air::IdentFragment(SPair(sym, S2), frag)),
Incomplete, // Eoh
]),
Sut::parse(toks.into_iter()).collect(),
);

102
tamer/src/obj/xmlo/reader/test.rs
View File

@ -39,6 +39,9 @@ use crate::{
type Sut = XmloReader;
use Parsed::{Incomplete, Object as O};
use XmloToken::*;
#[test]
fn fails_on_invalid_root() {
let tok = open("not-a-valid-package-node", S1, Depth(0));
@ -78,16 +81,16 @@ fn common_parses_package_attrs(package: QName) {
assert_eq!(
Ok(vec![
Parsed::Incomplete,
Parsed::Object(XmloToken::PkgName(SPair(name, S3))),
Parsed::Object(XmloToken::PkgRootPath(SPair(relroot, S3))),
Incomplete,
O(PkgName(SPair(name, S3))),
O(PkgRootPath(SPair(relroot, S3))),
// Span for the program flag is the attr name,
// rather than the value,
// since the value is just a boolean and does not provide as
// useful of context.
Parsed::Object(XmloToken::PkgProgramFlag(S3)),
Parsed::Object(XmloToken::PkgEligClassYields(SPair(elig, S4))),
Parsed::Incomplete,
O(PkgProgramFlag(S3)),
O(PkgEligClassYields(SPair(elig, S4))),
Incomplete,
]),
sut.collect(),
);
@ -124,10 +127,10 @@ fn ignores_unknown_package_attr() {
assert_eq!(
Ok(vec![
Parsed::Incomplete,
Parsed::Object(XmloToken::PkgName(SPair(name, S3))),
Parsed::Incomplete, // The unknown attribute
Parsed::Incomplete,
Incomplete,
O(PkgName(SPair(name, S3))),
Incomplete, // The unknown attribute
Incomplete,
]),
sut.collect(),
);
@ -144,7 +147,7 @@ fn symtable_err_missing_sym_name() {
let mut sut = SymtableState::parse(toks);
assert_eq!(sut.next(), Some(Ok(Parsed::Incomplete)),);
assert_eq!(sut.next(), Some(Ok(Incomplete)),);
assert_eq!(
sut.next(),
@ -182,16 +185,16 @@ macro_rules! symtable_tests {
match $expect {
Ok(expected) =>
Ok(vec![
Parsed::Incomplete, // Opening tag
Parsed::Incomplete, // @name
Incomplete, // Opening tag
Incomplete, // @name
$(
// For each attribute ($key here is necessary
// for macro iteration).
#[allow(unused)]
#[doc=stringify!($key)]
Parsed::Incomplete,
Incomplete,
)*
Parsed::Object(XmloToken::SymDecl(
O(SymDecl(
SPair(name, S3),
expected
)),
@ -345,10 +348,10 @@ fn symtable_sym_generated_true() {
assert_eq!(
Ok(vec![
Parsed::Incomplete, // Opening tag
Parsed::Incomplete, // @name
Parsed::Incomplete, // @preproc:generated
Parsed::Object(XmloToken::SymDecl(SPair(name, S3), expected)),
Incomplete, // Opening tag
Incomplete, // @name
Incomplete, // @preproc:generated
O(SymDecl(SPair(name, S3), expected)),
]),
SymtableState::parse(toks).collect(),
);
@ -382,13 +385,13 @@ fn symtable_map_from() {
assert_eq!(
Ok(vec![
Parsed::Incomplete, // Opening tag
Parsed::Incomplete, // @name
Parsed::Incomplete, // @type
Parsed::Incomplete, // <preproc:from
Parsed::Incomplete, // @name
Parsed::Incomplete, // />
Parsed::Object(XmloToken::SymDecl(SPair(name, S3), expected)),
Incomplete, // Opening tag
Incomplete, // @name
Incomplete, // @type
Incomplete, // <preproc:from
Incomplete, // @name
Incomplete, // />
O(SymDecl(SPair(name, S3), expected)),
]),
SymtableState::parse(toks).collect(),
);
@ -473,15 +476,15 @@ fn sym_dep_event() {
assert_eq!(
Ok(vec![
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloToken::SymDepStart(SPair(name, S1))), // @name
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloToken::Symbol(SPair(dep1, S4))), // @name
Parsed::Incomplete, // />
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloToken::Symbol(SPair(dep2, S5))), // @name
Parsed::Incomplete, // />
Parsed::Incomplete, // </preproc:sym-dep>
Incomplete, // <preproc:sym-ref
O(SymDepStart(SPair(name, S1))), // @name
Incomplete, // <preproc:sym-ref
O(Symbol(SPair(dep1, S4))), // @name
Incomplete, // />
Incomplete, // <preproc:sym-ref
O(Symbol(SPair(dep2, S5))), // @name
Incomplete, // />
Incomplete, // </preproc:sym-dep>
]),
SymDepsState::parse(toks).collect()
);
@ -546,14 +549,14 @@ fn sym_fragment_event() {
assert_eq!(
Ok(vec![
Parsed::Incomplete, // <preproc:fragment
Parsed::Incomplete, // @id
Parsed::Object(XmloToken::Fragment(SPair(id1, S1), frag1)), // text
Parsed::Incomplete, // </preproc:fragment>
Parsed::Incomplete, // <preproc:fragment
Parsed::Incomplete, // @id
Parsed::Object(XmloToken::Fragment(SPair(id2, S2), frag2)), // text
Parsed::Incomplete, // </preproc:fragment>
Incomplete, // <preproc:fragment
Incomplete, // @id
O(Fragment(SPair(id1, S1), frag1)), // text
Incomplete, // </preproc:fragment>
Incomplete, // <preproc:fragment
Incomplete, // @id
O(Fragment(SPair(id2, S2), frag2)), // text
Incomplete, // </preproc:fragment>
]),
FragmentsState::parse(toks).collect()
);
@ -666,16 +669,13 @@ fn xmlo_composite_parsers_header() {
assert_eq!(
Ok(vec![
Parsed::Object(XmloToken::SymDecl(
SPair(sym_name, S3),
Default::default(),
)),
Parsed::Object(XmloToken::SymDepStart(SPair(symdep_name, S3))),
Parsed::Object(XmloToken::Fragment(SPair(symfrag_id, S4), frag)),
Parsed::Object(XmloToken::Eoh(S3)),
O(SymDecl(SPair(sym_name, S3), Default::default(),)),
O(SymDepStart(SPair(symdep_name, S3))),
O(Fragment(SPair(symfrag_id, S4), frag)),
O(Eoh(S3)),
]),
sut.filter(|parsed| match parsed {
Ok(Parsed::Incomplete) => false,
Ok(Incomplete) => false,
_ => true,
})
.collect(),