diff options
Diffstat (limited to 'src/generator.rs')
-rw-r--r-- | src/generator.rs | 186 |
1 files changed, 139 insertions, 47 deletions
diff --git a/src/generator.rs b/src/generator.rs index bed56f3..87d1f00 100644 --- a/src/generator.rs +++ b/src/generator.rs @@ -9,21 +9,23 @@ use std::path::PathBuf; -use proc_macro2::{Span, TokenStream}; +use proc_macro2::TokenStream; use quote::{ToTokens, TokenStreamExt}; use syn::{self, Generics, Ident}; +use pest::unicode::unicode_property_names; use pest_meta::ast::*; use pest_meta::optimizer::*; -use pest_meta::UNICODE_PROPERTY_NAMES; -#[allow(clippy::needless_pass_by_value)] -pub fn generate( +use crate::docs::DocComment; + +pub(crate) fn generate( name: Ident, generics: &Generics, path: Option<PathBuf>, rules: Vec<OptimizedRule>, defaults: Vec<&str>, + doc_comment: &DocComment, include_grammar: bool, ) -> TokenStream { let uses_eoi = defaults.iter().any(|name| *name == "EOI"); @@ -37,7 +39,7 @@ pub fn generate( } else { quote!() }; - let rule_enum = generate_enum(&rules, uses_eoi); + let rule_enum = generate_enum(&rules, doc_comment, uses_eoi); let patterns = generate_patterns(&rules, uses_eoi); let skip = generate_skip(&rules); @@ -52,17 +54,20 @@ pub fn generate( let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + let result = result_type(); + let parser_impl = quote! { #[allow(clippy::all)] impl #impl_generics ::pest::Parser<Rule> for #name #ty_generics #where_clause { fn parse<'i>( rule: Rule, input: &'i str - ) -> ::std::result::Result< + ) -> #result< ::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule> > { mod rules { + #![allow(clippy::upper_case_acronyms)] pub mod hidden { use super::super::Rule; #skip @@ -98,7 +103,7 @@ fn generate_builtin_rules() -> Vec<(&'static str, TokenStream)> { let mut builtins = Vec::new(); insert_builtin!(builtins, ANY, state.skip(1)); - insert_public_builtin!( + insert_builtin!( builtins, EOI, state.rule(Rule::EOI, |state| state.end_of_input()) @@ -149,13 +154,15 @@ fn generate_builtin_rules() -> Vec<(&'static str, TokenStream)> { .or_else(|state| state.match_string("\r")) ); - for property in UNICODE_PROPERTY_NAMES { + let box_ty = box_type(); + + for property in unicode_property_names() { let property_ident: Ident = syn::parse_str(property).unwrap(); // insert manually for #property substitution builtins.push((property, quote! { #[inline] #[allow(dead_code, non_snake_case, unused_variables)] - fn #property_ident(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + fn #property_ident(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.match_char_by(::pest::unicode::#property_ident) } })); @@ -165,7 +172,7 @@ fn generate_builtin_rules() -> Vec<(&'static str, TokenStream)> { // Needed because Cargo doesn't watch for changes in grammars. fn generate_include(name: &Ident, path: &str) -> TokenStream { - let const_name = Ident::new(&format!("_PEST_GRAMMAR_{}", name), Span::call_site()); + let const_name = format_ident!("_PEST_GRAMMAR_{}", name); // Need to make this relative to the current directory since the path to the file // is derived from the CARGO_MANIFEST_DIR environment variable let mut current_dir = std::env::current_dir().expect("Unable to get current directory"); @@ -177,13 +184,26 @@ fn generate_include(name: &Ident, path: &str) -> TokenStream { } } -fn generate_enum(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { - let rules = rules - .iter() - .map(|rule| Ident::new(rule.name.as_str(), Span::call_site())); +fn generate_enum(rules: &[OptimizedRule], doc_comment: &DocComment, uses_eoi: bool) -> TokenStream { + let rules = rules.iter().map(|rule| { + let rule_name = format_ident!("r#{}", rule.name); + + match doc_comment.line_docs.get(&rule.name) { + Some(doc) => quote! { + #[doc = #doc] + #rule_name + }, + None => quote! { + #rule_name + }, + } + }); + + let grammar_doc = &doc_comment.grammar_doc; if uses_eoi { quote! { - #[allow(dead_code, non_camel_case_types)] + #[doc = #grammar_doc] + #[allow(dead_code, non_camel_case_types, clippy::upper_case_acronyms)] #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub enum Rule { EOI, @@ -192,7 +212,8 @@ fn generate_enum(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { } } else { quote! { - #[allow(dead_code, non_camel_case_types)] + #[doc = #grammar_doc] + #[allow(dead_code, non_camel_case_types, clippy::upper_case_acronyms)] #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub enum Rule { #( #rules ),* @@ -205,7 +226,8 @@ fn generate_patterns(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { let mut rules: Vec<TokenStream> = rules .iter() .map(|rule| { - let rule = Ident::new(rule.name.as_str(), Span::call_site()); + let rule = format_ident!("r#{}", rule.name); + quote! { Rule::#rule => rules::#rule(state) } @@ -224,10 +246,10 @@ fn generate_patterns(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { } fn generate_rule(rule: OptimizedRule) -> TokenStream { - let name = Ident::new(&rule.name, Span::call_site()); + let name = format_ident!("r#{}", rule.name); let expr = if rule.ty == RuleType::Atomic || rule.ty == RuleType::CompoundAtomic { generate_expr_atomic(rule.expr) - } else if name == "WHITESPACE" || name == "COMMENT" { + } else if rule.name == "WHITESPACE" || rule.name == "COMMENT" { let atomic = generate_expr_atomic(rule.expr); quote! { @@ -239,11 +261,13 @@ fn generate_rule(rule: OptimizedRule) -> TokenStream { generate_expr(rule.expr) }; + let box_ty = box_type(); + match rule.ty { RuleType::Normal => quote! { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn #name(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.rule(Rule::#name, |state| { #expr }) @@ -252,14 +276,14 @@ fn generate_rule(rule: OptimizedRule) -> TokenStream { RuleType::Silent => quote! { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn #name(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { #expr } }, RuleType::Atomic => quote! { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn #name(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.rule(Rule::#name, |state| { state.atomic(::pest::Atomicity::Atomic, |state| { #expr @@ -270,7 +294,7 @@ fn generate_rule(rule: OptimizedRule) -> TokenStream { RuleType::CompoundAtomic => quote! { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn #name(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.atomic(::pest::Atomicity::CompoundAtomic, |state| { state.rule(Rule::#name, |state| { #expr @@ -281,7 +305,7 @@ fn generate_rule(rule: OptimizedRule) -> TokenStream { RuleType::NonAtomic => quote! { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn #name(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.atomic(::pest::Atomicity::NonAtomic, |state| { state.rule(Rule::#name, |state| { #expr @@ -358,7 +382,7 @@ fn generate_expr(expr: OptimizedExpr) -> TokenStream { } } OptimizedExpr::Ident(ident) => { - let ident = Ident::new(&ident, Span::call_site()); + let ident = format_ident!("r#{}", ident); quote! { self::#ident(state) } } OptimizedExpr::PeekSlice(start, end_) => { @@ -504,7 +528,7 @@ fn generate_expr_atomic(expr: OptimizedExpr) -> TokenStream { } } OptimizedExpr::Ident(ident) => { - let ident = Ident::new(&ident, Span::call_site()); + let ident = format_ident!("r#{}", ident); quote! { self::#ident(state) } } OptimizedExpr::PeekSlice(start, end_) => { @@ -619,17 +643,45 @@ struct QuoteOption<T>(Option<T>); impl<T: ToTokens> ToTokens for QuoteOption<T> { fn to_tokens(&self, tokens: &mut TokenStream) { + let option = option_type(); tokens.append_all(match self.0 { - Some(ref t) => quote! { ::std::option::Option::Some(#t) }, - None => quote! { ::std::option::Option::None }, + Some(ref t) => quote! { #option::Some(#t) }, + None => quote! { #option::None }, }); } } +fn box_type() -> TokenStream { + #[cfg(feature = "std")] + quote! { ::std::boxed::Box } + + #[cfg(not(feature = "std"))] + quote! { ::alloc::boxed::Box } +} + +fn result_type() -> TokenStream { + #[cfg(feature = "std")] + quote! { ::std::result::Result } + + #[cfg(not(feature = "std"))] + quote! { ::core::result::Result } +} + +fn option_type() -> TokenStream { + #[cfg(feature = "std")] + quote! { ::std::option::Option } + + #[cfg(not(feature = "std"))] + quote! { ::core::option::Option } +} + #[cfg(test)] mod tests { use super::*; + use proc_macro2::Span; + use std::collections::HashMap; + #[test] fn rule_enum_simple() { let rules = vec![OptimizedRule { @@ -638,13 +690,23 @@ mod tests { expr: OptimizedExpr::Ident("g".to_owned()), }]; + let mut line_docs = HashMap::new(); + line_docs.insert("f".to_owned(), "This is rule comment".to_owned()); + + let doc_comment = &DocComment { + grammar_doc: "Rule doc\nhello".to_owned(), + line_docs, + }; + assert_eq!( - generate_enum(&rules, false).to_string(), + generate_enum(&rules, doc_comment, false).to_string(), quote! { - #[allow(dead_code, non_camel_case_types)] + #[doc = "Rule doc\nhello"] + #[allow(dead_code, non_camel_case_types, clippy::upper_case_acronyms)] #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub enum Rule { - f + #[doc = "This is rule comment"] + r#f } } .to_string() @@ -832,7 +894,7 @@ mod tests { assert_eq!( generate_expr(expr).to_string(), quote! { - self::a(state).or_else(|state| { + self::r#a(state).or_else(|state| { state.sequence(|state| { state.match_range('a'..'b').and_then(|state| { super::hidden::skip(state) @@ -898,7 +960,7 @@ mod tests { assert_eq!( generate_expr_atomic(expr).to_string(), quote! { - self::a(state).or_else(|state| { + self::r#a(state).or_else(|state| { state.sequence(|state| { state.match_range('a'..'b').and_then(|state| { state.lookahead(false, |state| { @@ -926,28 +988,50 @@ mod tests { } #[test] - fn generate_complete() { + fn test_generate_complete() { let name = Ident::new("MyParser", Span::call_site()); let generics = Generics::default(); - let rules = vec![OptimizedRule { - name: "a".to_owned(), - ty: RuleType::Silent, - expr: OptimizedExpr::Str("b".to_owned()), - }]; + + let rules = vec![ + OptimizedRule { + name: "a".to_owned(), + ty: RuleType::Silent, + expr: OptimizedExpr::Str("b".to_owned()), + }, + OptimizedRule { + name: "if".to_owned(), + ty: RuleType::Silent, + expr: OptimizedExpr::Ident("a".to_owned()), + }, + ]; + + let mut line_docs = HashMap::new(); + line_docs.insert("if".to_owned(), "If statement".to_owned()); + + let doc_comment = &DocComment { + line_docs, + grammar_doc: "This is Rule doc\nThis is second line".to_owned(), + }; + let defaults = vec!["ANY"]; + let result = result_type(); + let box_ty = box_type(); let mut current_dir = std::env::current_dir().expect("Unable to get current directory"); current_dir.push("test.pest"); let test_path = current_dir.to_str().expect("path contains invalid unicode"); assert_eq!( - generate(name, &generics, Some(PathBuf::from("test.pest")), rules, defaults, true).to_string(), + generate(name, &generics, Some(PathBuf::from("test.pest")), rules, defaults, doc_comment, true).to_string(), quote! { #[allow(non_upper_case_globals)] const _PEST_GRAMMAR_MyParser: &'static str = include_str!(#test_path); - #[allow(dead_code, non_camel_case_types)] + #[doc = "This is Rule doc\nThis is second line"] + #[allow(dead_code, non_camel_case_types, clippy::upper_case_acronyms)] #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub enum Rule { - a + r#a, + #[doc = "If statement"] + r#if } #[allow(clippy::all)] @@ -955,17 +1039,18 @@ mod tests { fn parse<'i>( rule: Rule, input: &'i str - ) -> ::std::result::Result< + ) -> #result< ::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule> > { mod rules { + #![allow(clippy::upper_case_acronyms)] pub mod hidden { use super::super::Rule; #[inline] #[allow(dead_code, non_snake_case, unused_variables)] - pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn skip(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { Ok(state) } } @@ -975,13 +1060,19 @@ mod tests { #[inline] #[allow(non_snake_case, unused_variables)] - pub fn a(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn r#a(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.match_string("b") } #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn r#if(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { + self::r#a(state) + } + + #[inline] #[allow(dead_code, non_snake_case, unused_variables)] - pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + pub fn ANY(state: #box_ty<::pest::ParserState<'_, Rule>>) -> ::pest::ParseResult<#box_ty<::pest::ParserState<'_, Rule>>> { state.skip(1) } } @@ -991,7 +1082,8 @@ mod tests { ::pest::state(input, |state| { match rule { - Rule::a => rules::a(state) + Rule::r#a => rules::r#a(state), + Rule::r#if => rules::r#if(state) } }) } |