From 50f586844c096d98a7d5b07332a6a77dac4ec933 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 10 Sep 2019 17:34:59 +0200 Subject: Rename various bits of the pest_consume API --- dhall_syntax/src/parser.rs | 6 +- pest_consume/src/lib.rs | 302 +++++++++++++++++--------------- pest_consume_macros/src/lib.rs | 2 +- pest_consume_macros/src/make_parser.rs | 8 +- pest_consume_macros/src/match_inputs.rs | 27 ++- 5 files changed, 180 insertions(+), 165 deletions(-) diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 0d529bc..74d2731 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -6,7 +6,7 @@ use std::rc::Rc; use dgp::Rule; use dhall_generated_parser as dgp; -use pest_consume::{make_parser, match_inputs, PestConsumer}; +use pest_consume::{match_inputs, Parser}; use crate::map::{DupTreeMap, DupTreeSet}; use crate::ExprF::*; @@ -20,7 +20,7 @@ use crate::*; type ParsedText = InterpolatedText>; type ParsedTextContents = InterpolatedTextContents>; type ParseInput<'input, 'data> = - pest_consume::ParseInput<'input, 'data, Rule, Rc>; + pest_consume::Node<'input, 'data, Rule, Rc>; pub type ParseError = pest::error::Error; pub type ParseResult = Result; @@ -150,7 +150,7 @@ lazy_static::lazy_static! { struct DhallParser; -#[make_parser(dgp::DhallParser, dgp::Rule)] +#[pest_consume::parser(dgp::DhallParser, dgp::Rule)] impl DhallParser { fn EOI(_input: ParseInput) -> ParseResult<()> { Ok(()) diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs index 62361f2..701fbba 100644 --- a/pest_consume/src/lib.rs +++ b/pest_consume/src/lib.rs @@ -1,183 +1,199 @@ -use pest::error::{Error, ErrorVariant}; -use pest::iterators::{Pair, Pairs}; +use pest::error::Error; use pest::Parser as PestParser; -use pest::{RuleType, Span}; +use pest::RuleType; -pub use pest_consume_macros::make_parser; #[proc_macro_hack::proc_macro_hack] pub use pest_consume_macros::match_inputs; +pub use pest_consume_macros::parser; static UNIT: () = (); -/// Carries a pest Pair alongside custom user data. -#[derive(Debug)] -pub struct ParseInput<'input, 'data, Rule: RuleType, Data> { - pair: Pair<'input, Rule>, - user_data: &'data Data, -} - -/// Iterator over `ParseInput`s. It is created by `ParseInput::children` or `ParseInputs::new`. -#[derive(Debug)] -pub struct ParseInputs<'input, 'data, Rule: RuleType, Data> { - pairs: Pairs<'input, Rule>, - span: Span<'input>, - user_data: &'data Data, -} +mod node { + use super::Parser; + use pest::error::{Error, ErrorVariant}; + use pest::iterators::{Pair, Pairs}; + use pest::Parser as PestParser; + use pest::{RuleType, Span}; -impl<'i, 'd, R: RuleType, D> ParseInput<'i, 'd, R, D> { - pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self { - ParseInput { pair, user_data } + /// Carries a pest Pair alongside custom user data. + #[derive(Debug)] + pub struct Node<'input, 'data, Rule: RuleType, Data> { + pair: Pair<'input, Rule>, + user_data: &'data Data, } - /// Create an error that points to the span of the input. - pub fn error(&self, message: String) -> Error { - Error::new_from_span( - ErrorVariant::CustomError { message }, - self.as_span(), - ) + + /// Iterator over `Node`s. It is created by `Node::children` or `Nodes::new`. + #[derive(Debug)] + pub struct Nodes<'input, 'data, Rule: RuleType, Data> { + pairs: Pairs<'input, Rule>, + span: Span<'input>, + user_data: &'data Data, } - /// Reconstruct the input with a new pair, passing the user data along. - pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self { - ParseInput { - pair: new_pair, - user_data: self.user_data, + + impl<'i, 'd, R: RuleType, D> Node<'i, 'd, R, D> { + pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self { + Node { pair, user_data } } - } - /// If the contained pair has exactly one child, return a new Self containing it. - pub fn single_child(&self) -> Option { - let mut children = self.pair.clone().into_inner(); - if let Some(child) = children.next() { - if children.next().is_none() { - return Some(self.with_pair(child)); + /// Create an error that points to the span of the input. + pub fn error(&self, message: String) -> Error { + Error::new_from_span( + ErrorVariant::CustomError { message }, + self.as_span(), + ) + } + /// Reconstruct the input with a new pair, passing the user data along. + pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self { + Node { + pair: new_pair, + user_data: self.user_data, } } - None - } - /// Return an iterator over the children of this input - // Can't use `-> impl Iterator` because of weird lifetime limitations - // (see https://github.com/rust-lang/rust/issues/61997). - pub fn children(&self) -> ParseInputs<'i, 'd, R, D> { - ParseInputs { - pairs: self.as_pair().clone().into_inner(), - span: self.as_span(), - user_data: self.user_data(), + /// If the contained pair has exactly one child, return a new Self containing it. + pub fn single_child(&self) -> Option { + let mut children = self.pair.clone().into_inner(); + if let Some(child) = children.next() { + if children.next().is_none() { + return Some(self.with_pair(child)); + } + } + None + } + /// Return an iterator over the children of this input + // Can't use `-> impl Iterator` because of weird lifetime limitations + // (see https://github.com/rust-lang/rust/issues/61997). + pub fn children(&self) -> Nodes<'i, 'd, R, D> { + Nodes { + pairs: self.as_pair().clone().into_inner(), + span: self.as_span(), + user_data: self.user_data(), + } } - } - pub fn user_data(&self) -> &'d D { - self.user_data - } - pub fn as_pair(&self) -> &Pair<'i, R> { - &self.pair - } - pub fn as_span(&self) -> Span<'i> { - self.pair.as_span() - } - pub fn as_str(&self) -> &'i str { - self.pair.as_str() - } - pub fn as_rule(&self) -> R { - self.pair.as_rule() + pub fn user_data(&self) -> &'d D { + self.user_data + } + pub fn as_pair(&self) -> &Pair<'i, R> { + &self.pair + } + pub fn as_span(&self) -> Span<'i> { + self.pair.as_span() + } + pub fn as_str(&self) -> &'i str { + self.pair.as_str() + } + pub fn as_rule(&self) -> R { + self.pair.as_rule() + } + pub fn as_aliased_rule(&self) -> C::AliasedRule + where + C: Parser, + ::Parser: PestParser, + { + C::rule_alias(self.as_rule()) + } } - pub fn as_rule_alias(&self) -> C::AliasedRule - where - C: PestConsumer, - ::Parser: PestParser, - { - C::rule_alias(self.as_rule()) + + impl<'i, 'd, R: RuleType, D> Nodes<'i, 'd, R, D> { + /// `input` must be the _original_ input that `pairs` is pointing to. + pub fn new( + input: &'i str, + pairs: Pairs<'i, R>, + user_data: &'d D, + ) -> Self { + let span = Span::new(input, 0, input.len()).unwrap(); + Nodes { + pairs, + span, + user_data, + } + } + /// Create an error that points to the span of the input. + pub fn error(&self, message: String) -> Error { + Error::new_from_span( + ErrorVariant::CustomError { message }, + self.span.clone(), + ) + } + pub fn aliased_rules(&self) -> Vec + where + C: Parser, + ::Parser: PestParser, + { + self.clone().map(|p| p.as_aliased_rule::()).collect() + } + /// Reconstruct the input with a new pair, passing the user data along. + fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, 'd, R, D> { + Node::new(new_pair, self.user_data) + } } -} -impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> { - /// `input` must be the _original_ input that `pairs` is pointing to. - pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: &'d D) -> Self { - let span = Span::new(input, 0, input.len()).unwrap(); - ParseInputs { - pairs, - span, - user_data, + impl<'i, 'd, R: RuleType, D> Iterator for Nodes<'i, 'd, R, D> { + type Item = Node<'i, 'd, R, D>; + + fn next(&mut self) -> Option { + let child_pair = self.pairs.next()?; + let child = self.with_pair(child_pair); + Some(child) } } - /// Create an error that points to the span of the input. - pub fn error(&self, message: String) -> Error { - Error::new_from_span( - ErrorVariant::CustomError { message }, - self.span.clone(), - ) + + impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for Nodes<'i, 'd, R, D> { + fn next_back(&mut self) -> Option { + let child_pair = self.pairs.next_back()?; + let child = self.with_pair(child_pair); + Some(child) + } } - pub fn aliased_rules(&self) -> Vec - where - C: PestConsumer, - ::Parser: PestParser, - { - self.clone().map(|p| p.as_rule_alias::()).collect() + + // Manual impl to avoid stupid `D: Clone` trait bound + impl<'i, 'd, R: RuleType, D> Clone for Node<'i, 'd, R, D> { + fn clone(&self) -> Self { + Node { + pair: self.pair.clone(), + user_data: self.user_data, + } + } } - /// Reconstruct the input with a new pair, passing the user data along. - fn with_pair(&self, new_pair: Pair<'i, R>) -> ParseInput<'i, 'd, R, D> { - ParseInput::new(new_pair, self.user_data) + + // Manual impl to avoid stupid `D: Clone` trait bound + impl<'i, 'd, R: RuleType, D> Clone for Nodes<'i, 'd, R, D> { + fn clone(&self) -> Self { + Nodes { + pairs: self.pairs.clone(), + span: self.span.clone(), + user_data: self.user_data, + } + } } } +pub use node::{Node, Nodes}; + /// Used by the macros. -pub trait PestConsumer { +/// Do not implement manually. +pub trait Parser { type Rule: RuleType; type AliasedRule: RuleType; type Parser: PestParser; + fn rule_alias(rule: Self::Rule) -> Self::AliasedRule; fn allows_shortcut(rule: Self::Rule) -> bool; - fn parse_with_userdata<'i, 'd, D>( - rule: Self::Rule, - input_str: &'i str, - user_data: &'d D, - ) -> Result, Error> { - let pairs = Self::Parser::parse(rule, input_str)?; - Ok(ParseInputs::new(input_str, pairs, user_data)) - } - + /// Parses a `&str` starting from `rule` fn parse<'i>( rule: Self::Rule, input_str: &'i str, - ) -> Result, Error> - { + ) -> Result, Error> { Self::parse_with_userdata(rule, input_str, &UNIT) } -} - -impl<'i, 'd, R: RuleType, D> Iterator for ParseInputs<'i, 'd, R, D> { - type Item = ParseInput<'i, 'd, R, D>; - - fn next(&mut self) -> Option { - let child_pair = self.pairs.next()?; - let child = self.with_pair(child_pair); - Some(child) - } -} - -impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for ParseInputs<'i, 'd, R, D> { - fn next_back(&mut self) -> Option { - let child_pair = self.pairs.next_back()?; - let child = self.with_pair(child_pair); - Some(child) - } -} - -// Manual impl to avoid stupid `D: Clone` trait bound -impl<'i, 'd, R: RuleType, D> Clone for ParseInput<'i, 'd, R, D> { - fn clone(&self) -> Self { - ParseInput { - pair: self.pair.clone(), - user_data: self.user_data, - } - } -} -// Manual impl to avoid stupid `D: Clone` trait bound -impl<'i, 'd, R: RuleType, D> Clone for ParseInputs<'i, 'd, R, D> { - fn clone(&self) -> Self { - ParseInputs { - pairs: self.pairs.clone(), - span: self.span.clone(), - user_data: self.user_data, - } + /// Parses a `&str` starting from `rule`, carrying `user_data` through the parser methods. + fn parse_with_userdata<'i, 'd, D>( + rule: Self::Rule, + input_str: &'i str, + user_data: &'d D, + ) -> Result, Error> { + let pairs = Self::Parser::parse(rule, input_str)?; + Ok(Nodes::new(input_str, pairs, user_data)) } } diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs index db21f37..7f9f464 100644 --- a/pest_consume_macros/src/lib.rs +++ b/pest_consume_macros/src/lib.rs @@ -11,7 +11,7 @@ mod match_inputs; use proc_macro::TokenStream; #[proc_macro_attribute] -pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream { +pub fn parser(attrs: TokenStream, input: TokenStream) -> TokenStream { TokenStream::from(match make_parser::make_parser(attrs, input) { Ok(tokens) => tokens, Err(err) => err.to_compile_error(), diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs index e8d861f..2ed3271 100644 --- a/pest_consume_macros/src/make_parser.rs +++ b/pest_consume_macros/src/make_parser.rs @@ -64,7 +64,7 @@ struct ParsedFn<'a> { function: &'a mut ImplItemMethod, // Name of the function. fn_name: Ident, - // Name of the first argument of the function, which should be of type `ParseInput`. + // Name of the first argument of the function, which should be of type `Node`. input_arg: Ident, // List of aliases pointing to this function alias_srcs: Vec, @@ -255,14 +255,14 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> { .map(|src| &src.ident) .filter(|i| i != &fn_name); let block = &function.block; - let self_ty = quote!(); + let self_ty = quote!(); function.block = parse_quote!({ let mut #input_arg = #input_arg; // While the current rule allows shortcutting, and there is a single child, and the // child can still be parsed by the current function, then skip to that child. while #self_ty::allows_shortcut(#input_arg.as_rule()) { if let Some(child) = #input_arg.single_child() { - if child.as_rule_alias::() == #self_ty::AliasedRule::#fn_name { + if child.as_aliased_rule::() == #self_ty::AliasedRule::#fn_name { #input_arg = child; continue; } @@ -375,7 +375,7 @@ pub fn make_parser( #(#aliased_rule_variants,)* } - impl #impl_generics ::pest_consume::PestConsumer for #ty #where_clause { + impl #impl_generics ::pest_consume::Parser for #ty #where_clause { type Rule = #rule_enum; type AliasedRule = AliasedRule; type Parser = #parser; diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs index 34bfd38..773f806 100644 --- a/pest_consume_macros/src/match_inputs.rs +++ b/pest_consume_macros/src/match_inputs.rs @@ -23,7 +23,7 @@ enum ChildrenBranchPatternItem { #[derive(Debug, Clone)] struct ParseChildrenInput { - consumer: Type, + parser: Type, input_expr: Expr, branches: Punctuated, } @@ -66,12 +66,12 @@ impl Parse for ChildrenBranchPatternItem { impl Parse for ParseChildrenInput { fn parse(input: ParseStream) -> Result { - let consumer = if input.peek(token::Lt) { + let parser = if input.peek(token::Lt) { let _: token::Lt = input.parse()?; - let consumer = input.parse()?; + let parser = input.parse()?; let _: token::Gt = input.parse()?; let _: Token![;] = input.parse()?; - consumer + parser } else { parse_quote!(Self) }; @@ -80,7 +80,7 @@ impl Parse for ParseChildrenInput { let branches = Punctuated::parse_terminated(input)?; Ok(ParseChildrenInput { - consumer, + parser, input_expr, branches, }) @@ -90,13 +90,12 @@ impl Parse for ParseChildrenInput { fn make_parser_branch( branch: &ChildrenBranch, i_inputs: &Ident, - consumer: &Type, + parser: &Type, ) -> Result { use ChildrenBranchPatternItem::{Multiple, Single}; let body = &branch.body; - let aliased_rule = - quote!(<#consumer as ::pest_consume::PestConsumer>::AliasedRule); + let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule); // Convert the input pattern into a pattern-match on the Rules of the children. This uses // slice_patterns. @@ -156,7 +155,7 @@ fn make_parser_branch( let mut parses = Vec::new(); for (rule_name, binder) in singles_before_multiple.into_iter() { parses.push(quote!( - let #binder = #consumer::#rule_name( + let #binder = #parser::#rule_name( #i_inputs.next().unwrap() )?; )) @@ -165,7 +164,7 @@ fn make_parser_branch( // only the unmatched inputs are left for the variable-length pattern, if any. for (rule_name, binder) in singles_after_multiple.into_iter().rev() { parses.push(quote!( - let #binder = #consumer::#rule_name( + let #binder = #parser::#rule_name( #i_inputs.next_back().unwrap() )?; )) @@ -173,7 +172,7 @@ fn make_parser_branch( if let Some((rule_name, binder)) = multiple { parses.push(quote!( let #binder = #i_inputs - .map(|i| #consumer::#rule_name(i)) + .map(|i| #parser::#rule_name(i)) .collect::, _>>()? .into_iter(); )) @@ -196,17 +195,17 @@ pub fn match_inputs( let i_inputs = Ident::new("___inputs", Span::call_site()); let input_expr = &input.input_expr; - let consumer = &input.consumer; + let parser = &input.parser; let branches = input .branches .iter() - .map(|br| make_parser_branch(br, &i_inputs, consumer)) + .map(|br| make_parser_branch(br, &i_inputs, parser)) .collect::>>()?; Ok(quote!({ #[allow(unused_mut)] let mut #i_inputs = #input_expr; - let #i_input_rules = #i_inputs.aliased_rules::<#consumer>(); + let #i_input_rules = #i_inputs.aliased_rules::<#parser>(); #[allow(unreachable_code)] match #i_input_rules.as_slice() { -- cgit v1.2.3