Separate both parser proc_macros into their own files

1 files changed, 1 insertions, 87 deletions

diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parse_children.rs
index a440b16..ce6f66c 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parse_children.rs
@@ -3,10 +3,7 @@ use quote::quote;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{
-    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, ImplItem,
-    ImplItemMethod, ItemImpl, Pat, ReturnType, Token,
-};
+use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
 
 #[derive(Debug, Clone)]
 struct ChildrenBranch {
@@ -76,89 +73,6 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn apply_special_attrs(
-    rule_enum: &Ident,
-    function: &mut ImplItemMethod,
-) -> Result<()> {
-    let recognized_attrs: Vec<_> = function
-        .attrs
-        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-        .collect();
-
-    let name = function.sig.ident.clone();
-    let output_type = match &function.sig.output {
-        ReturnType::Default => parse_quote!(()),
-        ReturnType::Type(_, t) => (**t).clone(),
-    };
-
-    if recognized_attrs.is_empty() {
-    } else if recognized_attrs.len() > 1 {
-        return Err(Error::new(
-            recognized_attrs[1].span(),
-            "expected a single prec_climb attribute",
-        ));
-    } else {
-        let attr = recognized_attrs.into_iter().next().unwrap();
-        let (child_rule, climber) =
-            attr.parse_args_with(|input: ParseStream| {
-                let child_rule: Ident = input.parse()?;
-                let _: Token![,] = input.parse()?;
-                let climber: Expr = input.parse()?;
-                Ok((child_rule, climber))
-            })?;
-
-        *function = parse_quote!(
-            fn #name<'a>(
-                input: ParseInput<'a, #rule_enum>,
-            ) -> #output_type {
-                #[allow(non_snake_case, dead_code)]
-                #function
-
-                #climber.climb(
-                    input.pair.clone().into_inner(),
-                    |p| Self::#child_rule(input.with_pair(p)),
-                    |l, op, r| {
-                        #name(input.clone(), l?, op, r?)
-                    },
-                )
-            }
-        );
-    }
-
-    *function = parse_quote!(
-        #[allow(non_snake_case, dead_code)]
-        #function
-    );
-
-    Ok(())
-}
-
-pub fn make_parser(
-    attrs: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let rule_enum: Ident = syn::parse(attrs)?;
-
-    let mut imp: ItemImpl = syn::parse(input)?;
-    imp.items
-        .iter_mut()
-        .map(|item| match item {
-            ImplItem::Method(m) => apply_special_attrs(&rule_enum, m),
-            _ => Ok(()),
-        })
-        .collect::<Result<()>>()?;
-
-    let ty = &imp.self_ty;
-    let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
-    Ok(quote!(
-        impl #impl_generics PestConsumer for #ty #where_clause {
-            type RuleEnum = #rule_enum;
-        }
-
-        #imp
-    ))
-}
-
 fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     use ChildrenBranchPatternItem::{Multiple, Single};