employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: obj::xmlo::{XmloEvent=>XmloToken} 

The original "event" name was based on quick-xml's `Event`.  This
terminology shift is more closely matched with the new parsing system.

DEV-11864
main
Mike Gerwitz 2022-05-05 12:25:59 -04:00
parent 0d999b56cd
commit ba9f429ee7
5 changed files with 75 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tamer/src/asg/base.rs
View File

@ -41,6 +41,7 @@ type Ix = global::ProgSymSize;
///
/// For more information,
/// see [`Asg`].
#[derive(Debug, Default)]
pub struct BaseAsg<O> {
// TODO: private; see `ld::xmle::lower`.
/// Directed graph on which objects are stored.

80
tamer/src/obj/xmlo/asg_builder.rs
View File

@ -24,7 +24,7 @@
//!
//! Usage
//! =====
//! [`AsgBuilder`] accepts any [`Iterator`] of [`XmloEvent`]s,
//! [`AsgBuilder`] accepts any [`Iterator`] of [`XmloToken`]s,
//! but is intended to be paired with [`XmloReader`](super::XmloReader).
//!
//! To fully load an `xmlo` file and its dependencies,
@ -38,7 +38,7 @@
//! used to take ownership over the data.
use super::{
reader::{XmloEvent, XmloResult},
reader::{XmloResult, XmloToken},
XmloError,
};
use crate::asg::{
@ -147,7 +147,7 @@ where
/// Its initial value can be provided as [`Default::default`].
fn import_xmlo(
&mut self,
xmlo: impl Iterator<Item = XmloResult<XmloEvent>>,
xmlo: impl Iterator<Item = XmloResult<XmloToken>>,
state: AsgBuilderState<S>,
) -> Result<S>;
}
@ -173,7 +173,7 @@ where
{
fn import_xmlo(
&mut self,
mut xmlo: impl Iterator<Item = XmloResult<XmloEvent>>,
mut xmlo: impl Iterator<Item = XmloResult<XmloToken>>,
mut state: AsgBuilderState<S>,
) -> Result<S> {
let mut elig = None;
@ -188,7 +188,7 @@ where
while let Some(ev) = xmlo.next() {
match (istate, ev?) {
(IS::None, XmloEvent::PkgName(name)) => {
(IS::None, XmloToken::PkgName(name)) => {
pkg_name = Some(name);
if first {
@ -196,29 +196,29 @@ where
}
}
(IS::None, XmloEvent::PkgRootPath(relroot)) => {
(IS::None, XmloToken::PkgRootPath(relroot)) => {
if first {
state.relroot = Some(relroot);
}
}
(IS::None, XmloEvent::PkgEligClassYields(pkg_elig)) => {
(IS::None, XmloToken::PkgEligClassYields(pkg_elig)) => {
elig = Some(pkg_elig);
}
(IS::None, XmloEvent::PkgProgramFlag) => {
(IS::None, XmloToken::PkgProgramFlag) => {
// Unused
}
(IS::None | IS::SymDep(_), XmloEvent::SymDepStart(sym, _)) => {
(IS::None | IS::SymDep(_), XmloToken::SymDepStart(sym, _)) => {
istate = IS::SymDep(sym);
}
(IS::SymDep(sym), XmloEvent::Symbol(dep_sym, _)) => {
(IS::SymDep(sym), XmloToken::Symbol(dep_sym, _)) => {
self.add_dep_lookup(sym, dep_sym);
}
(IS::None, XmloEvent::SymDecl(sym, attrs, _span)) => {
(IS::None, XmloToken::SymDecl(sym, attrs, _span)) => {
if let Some(sym_src) = attrs.src {
found.insert(sym_src);
} else {
@ -260,7 +260,7 @@ where
// Fragments follow SymDeps.
(
IS::None | IS::SymDep(_),
XmloEvent::Fragment(sym, text, _),
XmloToken::Fragment(sym, text, _),
) => {
istate = IS::None;
@ -276,7 +276,7 @@ where
// may change in the future, in which case this
// responsibility can be delegated to the linker (to produce
// an `Iterator` that stops at EOH).
(IS::None, XmloEvent::Eoh(_)) => break,
(IS::None, XmloToken::Eoh(_)) => break,
(istate, ev) => {
todo!("unexpected state transition: {istate:?} -> {ev:?}")
@ -389,8 +389,8 @@ mod test {
let relroot = "some/path".into();
let evs = vec![
Ok(XmloEvent::PkgName(name)),
Ok(XmloEvent::PkgRootPath(relroot)),
Ok(XmloToken::PkgName(name)),
Ok(XmloToken::PkgRootPath(relroot)),
];
let state = sut.import_xmlo(evs.into_iter(), SutState::new()).unwrap();
@ -422,7 +422,7 @@ mod test {
.declare(elig_sym, IdentKind::Meta, Default::default())
.unwrap();
let evs = vec![Ok(XmloEvent::PkgEligClassYields(elig_sym))];
let evs = vec![Ok(XmloToken::PkgEligClassYields(elig_sym))];
let state = sut.import_xmlo(evs.into_iter(), SutState::new()).unwrap();
@ -438,9 +438,9 @@ mod test {
let sym_to2 = "to2".intern();
let evs = vec![
Ok(XmloEvent::SymDepStart(sym_from, DUMMY_SPAN)),
Ok(XmloEvent::Symbol(sym_to1, DUMMY_SPAN)),
Ok(XmloEvent::Symbol(sym_to2, DUMMY_SPAN)),
Ok(XmloToken::SymDepStart(sym_from, DUMMY_SPAN)),
Ok(XmloToken::Symbol(sym_to1, DUMMY_SPAN)),
Ok(XmloToken::Symbol(sym_to2, DUMMY_SPAN)),
];
let _ = sut
@ -464,7 +464,7 @@ mod test {
let src_b = "src_b".intern();
let evs = vec![
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
src: Some(src_a),
@ -472,7 +472,7 @@ mod test {
},
UNKNOWN_SPAN,
)),
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
src: Some(src_b),
@ -515,7 +515,7 @@ mod test {
let evs = vec![
// Note that externs should not be recognized as roots even if
// their type would be.
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym_extern,
SymAttrs {
pkg_name: Some(pkg_name),
@ -526,7 +526,7 @@ mod test {
UNKNOWN_SPAN,
)),
// These three will be roots
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym_non_extern,
SymAttrs {
pkg_name: Some(pkg_name),
@ -535,7 +535,7 @@ mod test {
},
UNKNOWN_SPAN,
)),
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym_map,
SymAttrs {
pkg_name: Some(pkg_name),
@ -544,7 +544,7 @@ mod test {
},
UNKNOWN_SPAN,
)),
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym_retmap,
SymAttrs {
pkg_name: Some(pkg_name),
@ -636,7 +636,7 @@ mod test {
..Default::default()
};
let evs = vec![Ok(XmloEvent::SymDecl(
let evs = vec![Ok(XmloToken::SymDecl(
sym,
SymAttrs {
pkg_name: Some(pkg_name),
@ -677,8 +677,8 @@ mod test {
};
let evs = vec![
Ok(XmloEvent::PkgName(pkg_name)),
Ok(XmloEvent::SymDecl(
Ok(XmloToken::PkgName(pkg_name)),
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
ty: Some(SymType::Meta),
@ -711,7 +711,7 @@ mod test {
let sym = "sym".intern();
let bad_attrs = SymAttrs::default();
let evs = vec![Ok(XmloEvent::SymDecl(sym, bad_attrs, UNKNOWN_SPAN))];
let evs = vec![Ok(XmloToken::SymDecl(sym, bad_attrs, UNKNOWN_SPAN))];
let result = sut
.import_xmlo(evs.into_iter(), SutState::new())
@ -727,7 +727,7 @@ mod test {
let sym = "sym".intern();
let evs = vec![
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
extern_: true,
@ -737,7 +737,7 @@ mod test {
UNKNOWN_SPAN,
)),
// Incompatible
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
extern_: true,
@ -762,7 +762,7 @@ mod test {
let sym = "sym".intern();
let evs = vec![
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
ty: Some(SymType::Meta),
@ -771,7 +771,7 @@ mod test {
UNKNOWN_SPAN,
)),
// Redeclare
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
ty: Some(SymType::Meta),
@ -796,7 +796,7 @@ mod test {
let frag = FragmentText::from("foo");
let evs = vec![
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
ty: Some(SymType::Meta),
@ -804,7 +804,7 @@ mod test {
},
DUMMY_SPAN,
)),
Ok(XmloEvent::Fragment(sym, frag.clone(), DUMMY_SPAN)),
Ok(XmloToken::Fragment(sym, frag.clone(), DUMMY_SPAN)),
];
let _ = sut.import_xmlo(evs.into_iter(), SutState::new()).unwrap();
@ -831,7 +831,7 @@ mod test {
let sym = "sym".intern();
// Note: missing `SymDecl`.
let evs = vec![Ok(XmloEvent::Fragment(sym, "foo".into(), DUMMY_SPAN))];
let evs = vec![Ok(XmloToken::Fragment(sym, "foo".into(), DUMMY_SPAN))];
let result = sut
.import_xmlo(evs.into_iter(), SutState::new())
@ -848,7 +848,7 @@ mod test {
let frag = FragmentText::from("foo");
let evs = vec![
Ok(XmloEvent::SymDecl(
Ok(XmloToken::SymDecl(
sym,
SymAttrs {
// Invalid fragment destination
@ -858,7 +858,7 @@ mod test {
},
DUMMY_SPAN,
)),
Ok(XmloEvent::Fragment(sym, frag.clone(), DUMMY_SPAN)),
Ok(XmloToken::Fragment(sym, frag.clone(), DUMMY_SPAN)),
];
let result = sut
@ -889,9 +889,9 @@ mod test {
let evs = vec![
// Stop here.
Ok(XmloEvent::Eoh(DUMMY_SPAN)),
Ok(XmloToken::Eoh(DUMMY_SPAN)),
// Shouldn't make it to this one.
Ok(XmloEvent::PkgName(pkg_name)),
Ok(XmloToken::PkgName(pkg_name)),
];
let state = sut.import_xmlo(evs.into_iter(), SutState::new()).unwrap();

2
tamer/src/obj/xmlo/mod.rs
View File

@ -82,4 +82,4 @@ mod reader;
pub use asg_builder::{AsgBuilder, AsgBuilderError, AsgBuilderState};
pub use error::XmloError;
pub use ir::{Dim, SymAttrs, SymDtype, SymType};
pub use reader::{XmloEvent, XmloReader};
pub use reader::{XmloReader, XmloToken};

30
tamer/src/obj/xmlo/reader.rs
View File

@ -39,7 +39,7 @@ use crate::{
/// we should instead prefer not to put data into object files that won't
/// be useful and can't be easily skipped without parsing.
#[derive(Debug, PartialEq, Eq)]
pub enum XmloEvent {
pub enum XmloToken {
/// Canonical package name.
PkgName(SymbolId),
/// Relative path from package to project root.
@ -81,7 +81,7 @@ pub enum XmloEvent {
Eoh(Span),
}
impl parse::Object for XmloEvent {}
impl parse::Object for XmloToken {}
/// A [`Result`] with a hard-coded [`XmloError`] error type.
///
@ -122,7 +122,7 @@ qname_const! {
pub trait XmloState = ParseState<Token = Xirf, Context = EmptyContext>
where
<Self as ParseState>::Error: Into<XmloError>,
<Self as ParseState>::Object: Into<XmloEvent>;
<Self as ParseState>::Object: Into<XmloToken>;
#[derive(Debug, Default, PartialEq, Eq)]
pub enum XmloReader<
@ -155,7 +155,7 @@ impl<SS: XmloState, SD: XmloState, SF: XmloState> ParseState
for XmloReader<SS, SD, SF>
{
type Token = Xirf;
type Object = XmloEvent;
type Object = XmloToken;
type Error = XmloError;
fn parse_token(
@ -176,11 +176,11 @@ impl<SS: XmloState, SD: XmloState, SF: XmloState> ParseState
(Package, Xirf::Attr(Attr(name, value, _))) => {
Transition(Package).ok(match name {
QN_NAME => XmloEvent::PkgName(value),
QN_UUROOTPATH => XmloEvent::PkgRootPath(value),
QN_PROGRAM => XmloEvent::PkgProgramFlag,
QN_NAME => XmloToken::PkgName(value),
QN_UUROOTPATH => XmloToken::PkgRootPath(value),
QN_PROGRAM => XmloToken::PkgProgramFlag,
QN_ELIG_CLASS_YIELDS => {
XmloEvent::PkgEligClassYields(value)
XmloToken::PkgEligClassYields(value)
}
// Ignore unknown attributes for now to maintain BC,
// since no strict xmlo schema has been defined.
@ -229,7 +229,7 @@ impl<SS: XmloState, SD: XmloState, SF: XmloState> ParseState
(
Fragments(_, sf),
Xirf::Close(None | Some(QN_FRAGMENTS), span, _),
) if sf.is_accepting() => Transition(Eoh).ok(XmloEvent::Eoh(span)),
) if sf.is_accepting() => Transition(Eoh).ok(XmloToken::Eoh(span)),
(Fragments(span, sf), tok) => {
sf.delegate(ctx, tok, |sf| Fragments(span, sf))
@ -510,7 +510,7 @@ impl SymtableState {
}
}
impl From<(SymbolId, SymAttrs, Span)> for XmloEvent {
impl From<(SymbolId, SymAttrs, Span)> for XmloToken {
fn from(tup: (SymbolId, SymAttrs, Span)) -> Self {
match tup {
(sym, attrs, span) => Self::SymDecl(sym, attrs, span),
@ -539,7 +539,7 @@ pub enum SymDepsState {
impl ParseState for SymDepsState {
type Token = Xirf;
type Object = XmloEvent;
type Object = XmloToken;
type Error = XmloError;
fn parse_token(
@ -558,7 +558,7 @@ impl ParseState for SymDepsState {
(SymUnnamed(span), Xirf::Attr(Attr(QN_NAME, name, _))) => {
Transition(Sym(span, name))
.ok(XmloEvent::SymDepStart(name, span))
.ok(XmloToken::SymDepStart(name, span))
}
(SymUnnamed(span), _) => Transition(SymUnnamed(span))
@ -572,7 +572,7 @@ impl ParseState for SymDepsState {
SymRefUnnamed(span, name, span_ref),
Xirf::Attr(Attr(QN_NAME, ref_name, (_, span_ref_name))),
) => Transition(SymRefDone(span, name, span_ref))
.ok(XmloEvent::Symbol(ref_name, span_ref_name)),
.ok(XmloToken::Symbol(ref_name, span_ref_name)),
// TODO: For xmlns attributes, which will go away in XIRF.
(SymRefUnnamed(span, name, span_ref), Xirf::Attr(..)) => {
@ -626,7 +626,7 @@ pub enum FragmentsState {
impl ParseState for FragmentsState {
type Token = Xirf;
type Object = XmloEvent;
type Object = XmloToken;
type Error = XmloError;
fn parse_token(
@ -672,7 +672,7 @@ impl ParseState for FragmentsState {
(Fragment(span, id), Xirf::Text(text, _)) => {
Transition(FragmentDone(span, id))
.ok(XmloEvent::Fragment(id, text, span))
.ok(XmloToken::Fragment(id, text, span))
}
// TODO: Also a compiler bug, for some generated classes.

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

@ -82,10 +82,10 @@ fn common_parses_package_attrs(package: QName) {
assert_eq!(
Ok(vec![
Parsed::Incomplete,
Parsed::Object(XmloEvent::PkgName(name)),
Parsed::Object(XmloEvent::PkgRootPath(relroot)),
Parsed::Object(XmloEvent::PkgProgramFlag),
Parsed::Object(XmloEvent::PkgEligClassYields(elig)),
Parsed::Object(XmloToken::PkgName(name)),
Parsed::Object(XmloToken::PkgRootPath(relroot)),
Parsed::Object(XmloToken::PkgProgramFlag),
Parsed::Object(XmloToken::PkgEligClassYields(elig)),
Parsed::Incomplete,
]),
sut.collect(),
@ -124,7 +124,7 @@ fn ignores_unknown_package_attr() {
assert_eq!(
Ok(vec![
Parsed::Incomplete,
Parsed::Object(XmloEvent::PkgName(name)),
Parsed::Object(XmloToken::PkgName(name)),
Parsed::Incomplete, // The unknown attribute
Parsed::Incomplete,
]),
@ -470,12 +470,12 @@ fn sym_dep_event() {
assert_eq!(
Ok(vec![
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloEvent::SymDepStart(name, S1)), // @name
Parsed::Object(XmloToken::SymDepStart(name, S1)), // @name
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloEvent::Symbol(dep1, S4)), // @name
Parsed::Object(XmloToken::Symbol(dep1, S4)), // @name
Parsed::Incomplete, // />
Parsed::Incomplete, // <preproc:sym-ref
Parsed::Object(XmloEvent::Symbol(dep2, S5)), // @name
Parsed::Object(XmloToken::Symbol(dep2, S5)), // @name
Parsed::Incomplete, // />
Parsed::Incomplete, // </preproc:sym-dep>
]),
@ -515,7 +515,7 @@ fn sym_ref_missing_name() {
assert_eq!(
Err(ParseError::StateError(XmloError::MalformedSymRef(name, S2))),
SymDepsState::parse(toks)
.collect::<Result<Vec<Parsed<XmloEvent>>, _>>(),
.collect::<Result<Vec<Parsed<XmloToken>>, _>>(),
);
}
@ -544,11 +544,11 @@ fn sym_fragment_event() {
Ok(vec![
Parsed::Incomplete, // <preproc:fragment
Parsed::Incomplete, // @id
Parsed::Object(XmloEvent::Fragment(id1, frag1, S1)), // text
Parsed::Object(XmloToken::Fragment(id1, frag1, S1)), // text
Parsed::Incomplete, // </preproc:fragment>
Parsed::Incomplete, // <preproc:fragment
Parsed::Incomplete, // @id
Parsed::Object(XmloEvent::Fragment(id2, frag2, S2)), // text
Parsed::Object(XmloToken::Fragment(id2, frag2, S2)), // text
Parsed::Incomplete, // </preproc:fragment>
]),
FragmentsState::parse(toks).collect()
@ -567,7 +567,7 @@ fn sym_fragment_missing_id() {
assert_eq!(
Err(ParseError::StateError(XmloError::UnassociatedFragment(S1))),
FragmentsState::parse(toks)
.collect::<Result<Vec<Parsed<XmloEvent>>, _>>(),
.collect::<Result<Vec<Parsed<XmloToken>>, _>>(),
);
}
@ -585,7 +585,7 @@ fn sym_fragment_empty_id() {
assert_eq!(
Err(ParseError::StateError(XmloError::UnassociatedFragment(S1))),
FragmentsState::parse(toks)
.collect::<Result<Vec<Parsed<XmloEvent>>, _>>(),
.collect::<Result<Vec<Parsed<XmloToken>>, _>>(),
);
}
@ -608,7 +608,7 @@ fn _sym_fragment_missing_text() {
id, S1
))),
FragmentsState::parse(toks)
.collect::<Result<Vec<Parsed<XmloEvent>>, _>>(),
.collect::<Result<Vec<Parsed<XmloToken>>, _>>(),
);
}
@ -662,14 +662,14 @@ fn xmlo_composite_parsers_header() {
assert_eq!(
Ok(vec![
Parsed::Object(XmloEvent::SymDecl(
Parsed::Object(XmloToken::SymDecl(
sym_name,
Default::default(),
S3
)),
Parsed::Object(XmloEvent::SymDepStart(symdep_name, S3)),
Parsed::Object(XmloEvent::Fragment(symfrag_id, frag, S4)),
Parsed::Object(XmloEvent::Eoh(S3)),
Parsed::Object(XmloToken::SymDepStart(symdep_name, S3)),
Parsed::Object(XmloToken::Fragment(symfrag_id, frag, S4)),
Parsed::Object(XmloToken::Eoh(S3)),
]),
sut.filter(|parsed| match parsed {
Ok(Parsed::Incomplete) => false,