From 725805dc795159399c90a5c9b6f11ffeadec2e0f Mon Sep 17 00:00:00 2001 From: Wilco Kusee Date: Sun, 3 Mar 2019 10:40:03 +0100 Subject: Split parse and expand errors --- crates/ra_mbe/src/lib.rs | 13 +++++--- crates/ra_mbe/src/mbe_expander.rs | 65 ++++++++++++++++++++------------------- crates/ra_mbe/src/mbe_parser.rs | 24 +++++++-------- crates/ra_mbe/src/tt_cursor.rs | 44 +++++++++++++------------- 4 files changed, 74 insertions(+), 72 deletions(-) diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs index 8a2d6ff63..34840dfa1 100644 --- a/crates/ra_mbe/src/lib.rs +++ b/crates/ra_mbe/src/lib.rs @@ -25,14 +25,17 @@ use ra_syntax::SmolStr; pub use tt::{Delimiter, Punct}; #[derive(Debug, PartialEq, Eq)] -pub enum MacroRulesError { +pub enum ParseError { + ParseError, +} + +#[derive(Debug, PartialEq, Eq)] +pub enum ExpandError { NoMatchingRule, UnexpectedToken, BindingError(String), - ParseError, } -pub type Result = ::std::result::Result; pub use crate::syntax_bridge::{ast_to_token_tree, token_tree_to_ast_item_list}; /// This struct contains AST for a single `macro_rules` definition. What might @@ -45,10 +48,10 @@ pub struct MacroRules { } impl MacroRules { - pub fn parse(tt: &tt::Subtree) -> Result { + pub fn parse(tt: &tt::Subtree) -> Result { mbe_parser::parse(tt) } - pub fn expand(&self, tt: &tt::Subtree) -> Result { + pub fn expand(&self, tt: &tt::Subtree) -> Result { mbe_expander::expand(self, tt) } } diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs index 0a5bbf6b1..d4ce3bfe3 100644 --- a/crates/ra_mbe/src/mbe_expander.rs +++ b/crates/ra_mbe/src/mbe_expander.rs @@ -5,22 +5,21 @@ use rustc_hash::FxHashMap; use ra_syntax::SmolStr; use tt::TokenId; -use crate::{MacroRulesError, Result}; +use crate::ExpandError; use crate::tt_cursor::TtCursor; -pub(crate) fn expand(rules: &crate::MacroRules, input: &tt::Subtree) -> Result { - rules - .rules - .iter() - .find_map(|it| expand_rule(it, input).ok()) - .ok_or(MacroRulesError::NoMatchingRule) +pub(crate) fn expand( + rules: &crate::MacroRules, + input: &tt::Subtree, +) -> Result { + rules.rules.iter().find_map(|it| expand_rule(it, input).ok()).ok_or(ExpandError::NoMatchingRule) } -fn expand_rule(rule: &crate::Rule, input: &tt::Subtree) -> Result { +fn expand_rule(rule: &crate::Rule, input: &tt::Subtree) -> Result { let mut input = TtCursor::new(input); let bindings = match_lhs(&rule.lhs, &mut input)?; if !input.is_eof() { - return Err(MacroRulesError::UnexpectedToken); + return Err(ExpandError::UnexpectedToken); } expand_subtree(&rule.rhs, &bindings, &mut Vec::new()) } @@ -82,29 +81,30 @@ enum Binding { } impl Bindings { - fn get(&self, name: &SmolStr, nesting: &[usize]) -> Result<&tt::TokenTree> { + fn get(&self, name: &SmolStr, nesting: &[usize]) -> Result<&tt::TokenTree, ExpandError> { let mut b = self .inner .get(name) - .ok_or(MacroRulesError::BindingError(format!("could not find binding {}", name)))?; + .ok_or(ExpandError::BindingError(format!("could not find binding {}", name)))?; for &idx in nesting.iter() { b = match b { Binding::Simple(_) => break, - Binding::Nested(bs) => bs.get(idx).ok_or(MacroRulesError::BindingError( - format!("could not find nested binding {}", name), - ))?, + Binding::Nested(bs) => bs.get(idx).ok_or(ExpandError::BindingError(format!( + "could not find nested binding {}", + name + )))?, }; } match b { Binding::Simple(it) => Ok(it), - Binding::Nested(_) => Err(MacroRulesError::BindingError(format!( + Binding::Nested(_) => Err(ExpandError::BindingError(format!( "expected simple binding, found nested binding {}", name ))), } } - fn push_nested(&mut self, nested: Bindings) -> Result<()> { + fn push_nested(&mut self, nested: Bindings) -> Result<(), ExpandError> { for (key, value) in nested.inner { if !self.inner.contains_key(&key) { self.inner.insert(key.clone(), Binding::Nested(Vec::new())); @@ -112,10 +112,10 @@ impl Bindings { match self.inner.get_mut(&key) { Some(Binding::Nested(it)) => it.push(value), _ => { - return Err(MacroRulesError::BindingError(format!( + return Err(ExpandError::BindingError(format!( "nested binding for {} not found", key - ))) + ))); } } } @@ -123,43 +123,44 @@ impl Bindings { } } -fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result { +fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result { let mut res = Bindings::default(); for pat in pattern.token_trees.iter() { match pat { crate::TokenTree::Leaf(leaf) => match leaf { crate::Leaf::Var(crate::Var { text, kind }) => { - let kind = kind.clone().ok_or(MacroRulesError::ParseError)?; + let kind = kind.clone().ok_or(ExpandError::UnexpectedToken)?; match kind.as_str() { "ident" => { - let ident = input.eat_ident()?.clone(); + let ident = + input.eat_ident().ok_or(ExpandError::UnexpectedToken)?.clone(); res.inner.insert( text.clone(), Binding::Simple(tt::Leaf::from(ident).into()), ); } - _ => return Err(MacroRulesError::UnexpectedToken), + _ => return Err(ExpandError::UnexpectedToken), } } crate::Leaf::Punct(punct) => { - if input.eat_punct()? != punct { - return Err(MacroRulesError::UnexpectedToken); + if input.eat_punct() != Some(punct) { + return Err(ExpandError::UnexpectedToken); } } crate::Leaf::Ident(ident) => { - if input.eat_ident()?.text != ident.text { - return Err(MacroRulesError::UnexpectedToken); + if input.eat_ident().map(|i| &i.text) != Some(&ident.text) { + return Err(ExpandError::UnexpectedToken); } } - _ => return Err(MacroRulesError::UnexpectedToken), + _ => return Err(ExpandError::UnexpectedToken), }, crate::TokenTree::Repeat(crate::Repeat { subtree, kind: _, separator }) => { while let Ok(nested) = match_lhs(subtree, input) { res.push_nested(nested)?; if let Some(separator) = *separator { if !input.is_eof() { - if input.eat_punct()?.char != separator { - return Err(MacroRulesError::UnexpectedToken); + if input.eat_punct().map(|p| p.char) != Some(separator) { + return Err(ExpandError::UnexpectedToken); } } } @@ -175,12 +176,12 @@ fn expand_subtree( template: &crate::Subtree, bindings: &Bindings, nesting: &mut Vec, -) -> Result { +) -> Result { let token_trees = template .token_trees .iter() .map(|it| expand_tt(it, bindings, nesting)) - .collect::>>()?; + .collect::, ExpandError>>()?; Ok(tt::Subtree { token_trees, delimiter: template.delimiter }) } @@ -189,7 +190,7 @@ fn expand_tt( template: &crate::TokenTree, bindings: &Bindings, nesting: &mut Vec, -) -> Result { +) -> Result { let res: tt::TokenTree = match template { crate::TokenTree::Subtree(subtree) => expand_subtree(subtree, bindings, nesting)?.into(), crate::TokenTree::Repeat(repeat) => { diff --git a/crates/ra_mbe/src/mbe_parser.rs b/crates/ra_mbe/src/mbe_parser.rs index ee1b11091..d067e5248 100644 --- a/crates/ra_mbe/src/mbe_parser.rs +++ b/crates/ra_mbe/src/mbe_parser.rs @@ -1,10 +1,10 @@ /// This module parses a raw `tt::TokenStream` into macro-by-example token /// stream. This is a *mostly* identify function, expect for handling of /// `$var:tt_kind` and `$(repeat),*` constructs. -use crate::{MacroRulesError, Result}; +use crate::ParseError; use crate::tt_cursor::TtCursor; -pub(crate) fn parse(tt: &tt::Subtree) -> Result { +pub(crate) fn parse(tt: &tt::Subtree) -> Result { let mut parser = TtCursor::new(tt); let mut rules = Vec::new(); while !parser.is_eof() { @@ -19,7 +19,7 @@ pub(crate) fn parse(tt: &tt::Subtree) -> Result { Ok(crate::MacroRules { rules }) } -fn parse_rule(p: &mut TtCursor) -> Result { +fn parse_rule(p: &mut TtCursor) -> Result { let lhs = parse_subtree(p.eat_subtree()?)?; p.expect_char('=')?; p.expect_char('>')?; @@ -28,14 +28,14 @@ fn parse_rule(p: &mut TtCursor) -> Result { Ok(crate::Rule { lhs, rhs }) } -fn parse_subtree(tt: &tt::Subtree) -> Result { +fn parse_subtree(tt: &tt::Subtree) -> Result { let mut token_trees = Vec::new(); let mut p = TtCursor::new(tt); - while let Ok(tt) = p.eat() { + while let Some(tt) = p.eat() { let child: crate::TokenTree = match tt { tt::TokenTree::Leaf(leaf) => match leaf { tt::Leaf::Punct(tt::Punct { char: '$', .. }) => { - if p.at_ident().is_ok() { + if p.at_ident().is_some() { crate::Leaf::from(parse_var(&mut p)?).into() } else { parse_repeat(&mut p)?.into() @@ -56,12 +56,12 @@ fn parse_subtree(tt: &tt::Subtree) -> Result { Ok(crate::Subtree { token_trees, delimiter: tt.delimiter }) } -fn parse_var(p: &mut TtCursor) -> Result { +fn parse_var(p: &mut TtCursor) -> Result { let ident = p.eat_ident().unwrap(); let text = ident.text.clone(); let kind = if p.at_char(':') { p.bump(); - if let Ok(ident) = p.eat_ident() { + if let Some(ident) = p.eat_ident() { Some(ident.text.clone()) } else { p.rev_bump(); @@ -73,21 +73,21 @@ fn parse_var(p: &mut TtCursor) -> Result { Ok(crate::Var { text, kind }) } -fn parse_repeat(p: &mut TtCursor) -> Result { +fn parse_repeat(p: &mut TtCursor) -> Result { let subtree = p.eat_subtree().unwrap(); let mut subtree = parse_subtree(subtree)?; subtree.delimiter = crate::Delimiter::None; - let sep = p.eat_punct()?; + let sep = p.eat_punct().ok_or(ParseError::ParseError)?; let (separator, rep) = match sep.char { '*' | '+' | '?' => (None, sep.char), - char => (Some(char), p.eat_punct()?.char), + char => (Some(char), p.eat_punct().ok_or(ParseError::ParseError)?.char), }; let kind = match rep { '*' => crate::RepeatKind::ZeroOrMore, '+' => crate::RepeatKind::OneOrMore, '?' => crate::RepeatKind::ZeroOrOne, - _ => return Err(MacroRulesError::ParseError), + _ => return Err(ParseError::ParseError), }; p.bump(); Ok(crate::Repeat { subtree, kind, separator }) diff --git a/crates/ra_mbe/src/tt_cursor.rs b/crates/ra_mbe/src/tt_cursor.rs index 117471841..d06bfbf9f 100644 --- a/crates/ra_mbe/src/tt_cursor.rs +++ b/crates/ra_mbe/src/tt_cursor.rs @@ -1,4 +1,4 @@ -use crate::{MacroRulesError, Result}; +use crate::ParseError; #[derive(Clone)] pub(crate) struct TtCursor<'a> { @@ -19,24 +19,24 @@ impl<'a> TtCursor<'a> { self.subtree.token_trees.get(self.pos) } - pub(crate) fn at_punct(&self) -> Result<&'a tt::Punct> { + pub(crate) fn at_punct(&self) -> Option<&'a tt::Punct> { match self.current() { - Some(tt::TokenTree::Leaf(tt::Leaf::Punct(it))) => Ok(it), - _ => Err(MacroRulesError::ParseError), + Some(tt::TokenTree::Leaf(tt::Leaf::Punct(it))) => Some(it), + _ => None, } } pub(crate) fn at_char(&self, char: char) -> bool { match self.at_punct() { - Ok(tt::Punct { char: c, .. }) if *c == char => true, + Some(tt::Punct { char: c, .. }) if *c == char => true, _ => false, } } - pub(crate) fn at_ident(&mut self) -> Result<&'a tt::Ident> { + pub(crate) fn at_ident(&mut self) -> Option<&'a tt::Ident> { match self.current() { - Some(tt::TokenTree::Leaf(tt::Leaf::Ident(i))) => Ok(i), - _ => Err(MacroRulesError::ParseError), + Some(tt::TokenTree::Leaf(tt::Leaf::Ident(i))) => Some(i), + _ => None, } } @@ -47,45 +47,43 @@ impl<'a> TtCursor<'a> { self.pos -= 1; } - pub(crate) fn eat(&mut self) -> Result<&'a tt::TokenTree> { - match self.current() { - Some(it) => { - self.bump(); - Ok(it) - } - None => Err(MacroRulesError::ParseError), - } + pub(crate) fn eat(&mut self) -> Option<&'a tt::TokenTree> { + self.current().map(|it| { + self.bump(); + it + }) } - pub(crate) fn eat_subtree(&mut self) -> Result<&'a tt::Subtree> { + pub(crate) fn eat_subtree(&mut self) -> Result<&'a tt::Subtree, ParseError> { match self.current() { Some(tt::TokenTree::Subtree(sub)) => { self.bump(); Ok(sub) } - _ => Err(MacroRulesError::ParseError), + _ => Err(ParseError::ParseError), } } - pub(crate) fn eat_punct(&mut self) -> Result<&'a tt::Punct> { + pub(crate) fn eat_punct(&mut self) -> Option<&'a tt::Punct> { self.at_punct().map(|it| { self.bump(); it }) } - pub(crate) fn eat_ident(&mut self) -> Result<&'a tt::Ident> { + pub(crate) fn eat_ident(&mut self) -> Option<&'a tt::Ident> { self.at_ident().map(|i| { self.bump(); i }) } - pub(crate) fn expect_char(&mut self, char: char) -> Result<()> { + pub(crate) fn expect_char(&mut self, char: char) -> Result<(), ParseError> { if self.at_char(char) { self.bump(); - return Ok(()); + Ok(()) + } else { + Err(ParseError::ParseError) } - Err(MacroRulesError::ParseError) } } -- cgit v1.2.3