tamer: xir::tree::attr::parse::AttrParse{r=>}State

Simply correcting a naming inconsistency between the trait and the concrete
type.

DEV-11339 / DEV-11268

tamer/src/xir/tree.rs

@@ -177,7 +177,7 @@ mod attr;
 pub mod parse;
 
 use self::{
-    attr::{AttrParseError, AttrParserState},
+    attr::{AttrParseError, AttrParseState},
     parse::{
         ParseError, ParseResult, ParseState, ParseStateResult, ParseStatus,
         ParsedResult,
@@ -468,7 +468,7 @@ impl ElementStack {
 /// For more information,
 ///   see the [module-level documentation](self).
 #[derive(Debug, Eq, PartialEq)]
-pub enum Stack<SA = AttrParserState>
+pub enum Stack<SA = AttrParseState>
 where
     SA: StackAttrParseState,
 {
@@ -744,7 +744,7 @@ impl Error for StackError {
 pub fn parse(
     toks: impl TokenStream,
 ) -> impl Iterator<Item = ParsedResult<Stack>> {
-    Stack::<AttrParserState>::parse(toks)
+    Stack::<AttrParseState>::parse(toks)
 }
 
 /// Produce a lazy parser from a given [`TokenStream`],
@@ -773,7 +773,7 @@ pub fn parse(
 pub fn parser_from(
     toks: impl TokenStream,
 ) -> impl Iterator<Item = ParseResult<Stack, Tree>> {
-    Stack::<AttrParserState>::parse(toks).filter_map(|parsed| match parsed {
+    Stack::<AttrParseState>::parse(toks).filter_map(|parsed| match parsed {
         Ok(Parsed::Object(tree)) => Some(Ok(tree)),
         Ok(Parsed::Incomplete) => None,
         Err(x) => Some(Err(x)),
@@ -806,7 +806,7 @@ pub fn attr_parser_from<'a>(
 ) -> impl Iterator<Item = result::Result<Attr, ParseError<StackError>>> {
     use parse::Parsed;
 
-    AttrParserState::parse(toks).filter_map(|parsed| match parsed {
+    AttrParseState::parse(toks).filter_map(|parsed| match parsed {
         Ok(Parsed::Object(attr)) => Some(Ok(attr)),
         Ok(Parsed::Incomplete) => None,
         Err(ParseError::StateError(e)) => {

tamer/src/xir/tree/attr.rs

@@ -29,7 +29,7 @@ use super::QName;
 use crate::{span::Span, sym::SymbolId};
 use std::fmt::Display;
 
-pub use parse::{AttrParseError, AttrParserState};
+pub use parse::{AttrParseError, AttrParseState};
 
 /// Element attribute.
 #[derive(Debug, Clone, Eq, PartialEq)]

tamer/src/xir/tree/attr/parse.rs

@@ -39,17 +39,17 @@ use super::Attr;
 /// The actual parsing operation is therefore a FSM,
 ///   not a PDA.
 #[derive(Debug, Eq, PartialEq)]
-pub enum AttrParserState {
+pub enum AttrParseState {
     Empty,
     Name(QName, Span),
 }
 
-impl ParseState for AttrParserState {
+impl ParseState for AttrParseState {
     type Object = Attr;
     type Error = AttrParseError;
 
     fn parse_token(&mut self, tok: Token) -> ParseStateResult<Self> {
-        use AttrParserState::*;
+        use AttrParseState::*;
 
         match (take(self), tok) {
             (Empty, Token::AttrName(name, span)) => {
@@ -77,7 +77,7 @@ impl ParseState for AttrParserState {
     }
 }
 
-impl Default for AttrParserState {
+impl Default for AttrParseState {
     fn default() -> Self {
         Self::Empty
     }
@@ -136,7 +136,7 @@ mod test {
     fn dead_if_first_token_is_non_attr() {
         let tok = Token::Open("foo".unwrap_into(), *S);
 
-        let mut sut = AttrParserState::default();
+        let mut sut = AttrParseState::default();
 
         // There is no state that we can transition to,
         //   and we're in an empty accepting state.
@@ -144,7 +144,7 @@ mod test {
 
         // Let's just make sure we're in the same state we started in so
         //   that we know we can accommodate recovery token(s).
-        assert_eq!(sut, AttrParserState::default());
+        assert_eq!(sut, AttrParseState::default());
     }
 
     #[test]
@@ -152,7 +152,7 @@ mod test {
         let attr = "attr".unwrap_into();
         let val = "val".intern();
 
-        let mut sut = AttrParserState::default();
+        let mut sut = AttrParseState::default();
         let expected = Attr::new(attr, val, (*S, *S2));
 
         // First token represents the name,
@@ -174,7 +174,7 @@ mod test {
     fn parse_fails_when_attribute_value_missing_but_can_recover() {
         let attr = "bad".unwrap_into();
 
-        let mut sut = AttrParserState::default();
+        let mut sut = AttrParseState::default();
 
         // This token indicates that we're expecting a value to come next in
         //   the token stream.