Refactor ground for union macros reimplementation

Author: tyranron

juniper_codegen/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "juniper_codegen"
 version = "0.14.2"
+edition = "2018"
 authors = [
     "Magnus Hallin <[email protected]>",
     "Christoph Herzog <[email protected]>",
@@ -9,20 +10,19 @@ description = "Internal custom derive trait for Juniper GraphQL"
 license = "BSD-2-Clause"
 documentation = "https://docs.rs/juniper"
 repository = "https://github.com/graphql-rust/juniper"
-edition = "2018"
+
+[badges]
+travis-ci = { repository = "graphql-rust/juniper" }
 
 [lib]
 proc-macro = true
 
 [dependencies]
+proc-macro-error = "1.0.2"
 proc-macro2 = "1.0.1"
-syn = { version = "1.0.3", features = ["full", "extra-traits", "parsing"] }
 quote = "1.0.3"
-futures = "0.3.1"
-proc-macro-error = "1.0.2"
+syn = { version = "1.0.3", features = ["full", "extra-traits", "parsing"] }
 
 [dev-dependencies]
-juniper = { version = "0.14.2", path = "../juniper"}
-
-[badges]
-travis-ci = { repository = "graphql-rust/juniper" }
+futures = "0.3.1"
+juniper = { version = "0.14.2", path = "../juniper" }

juniper_codegen/src/derive_union.rs

@@ -1,20 +1,25 @@
-use crate::{
-    result::{GraphQLScope, UnsupportedAttribute},
-    util::{self, span_container::SpanContainer},
-};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields};
 
-pub fn build_derive_union(
-    ast: syn::DeriveInput,
-    is_internal: bool,
-    error: GraphQLScope,
-) -> syn::Result<TokenStream> {
+use crate::{
+    result::{GraphQLScope, UnsupportedAttribute},
+    util::{self, span_container::SpanContainer, Mode},
+};
+
+const SCOPE: GraphQLScope = GraphQLScope::DeriveUnion;
+
+pub fn expand(input: TokenStream, mode: Mode) -> syn::Result<TokenStream> {
+    let is_internal = matches!(mode, Mode::Internal);
+
+    let ast =
+        syn::parse2::<syn::DeriveInput>(input).unwrap_or_else(|e| proc_macro_error::abort!(e));
+
     let ast_span = ast.span();
     let enum_fields = match ast.data {
         Data::Enum(data) => data.variants,
-        _ => return Err(error.custom_error(ast_span, "can only be applied to enums")),
+        Data::Struct(_) => unimplemented!(),
+        _ => return Err(SCOPE.custom_error(ast_span, "can only be applied to enums and structs")),
     };
 
     // Parse attributes.
@@ -43,7 +48,7 @@ pub fn build_derive_union(
             };
 
             if let Some(ident) = field_attrs.skip {
-                error.unsupported_attribute_within(ident.span(), UnsupportedAttribute::Skip);
+                SCOPE.unsupported_attribute_within(ident.span(), UnsupportedAttribute::Skip);
                 return None;
             }
 
@@ -67,7 +72,7 @@ pub fn build_derive_union(
                     };
 
                     if iter.next().is_some() {
-                        error.custom(
+                        SCOPE.custom(
                             inner.span(),
                             "all members must be unnamed with a single element e.g. Some(T)",
                         );
@@ -76,7 +81,7 @@ pub fn build_derive_union(
                     first.ty.clone()
                 }
                 _ => {
-                    error.custom(
+                    SCOPE.custom(
                         variant_name.span(),
                         "only unnamed fields with a single element are allowed, e.g., Some(T)",
                     );
@@ -86,21 +91,21 @@ pub fn build_derive_union(
             };
 
             if let Some(description) = field_attrs.description {
-                error.unsupported_attribute_within(
+                SCOPE.unsupported_attribute_within(
                     description.span_ident(),
                     UnsupportedAttribute::Description,
                 );
             }
 
             if let Some(default) = field_attrs.default {
-                error.unsupported_attribute_within(
+                SCOPE.unsupported_attribute_within(
                     default.span_ident(),
                     UnsupportedAttribute::Default,
                 );
             }
 
             if name.starts_with("__") {
-                error.no_double_underscore(if let Some(name) = field_attrs.name {
+                SCOPE.no_double_underscore(if let Some(name) = field_attrs.name {
                     name.span_ident()
                 } else {
                     variant_name.span()
@@ -127,16 +132,16 @@ pub fn build_derive_union(
 
     if !attrs.interfaces.is_empty() {
         attrs.interfaces.iter().for_each(|elm| {
-            error.unsupported_attribute(elm.span(), UnsupportedAttribute::Interface)
+            SCOPE.unsupported_attribute(elm.span(), UnsupportedAttribute::Interface)
         });
     }
 
     if fields.is_empty() {
-        error.not_empty(ast_span);
+        SCOPE.not_empty(ast_span);
     }
 
     if name.starts_with("__") && !is_internal {
-        error.no_double_underscore(if let Some(name) = attrs.name {
+        SCOPE.no_double_underscore(if let Some(name) = attrs.name {
             name.span_ident()
         } else {
             ident.span()
@@ -157,7 +162,7 @@ pub fn build_derive_union(
     };
 
     if !all_variants_different {
-        error.custom(ident.span(), "each variant must have a different type");
+        SCOPE.custom(ident.span(), "each variant must have a different type");
     }
 
     // Early abort after GraphQL properties

juniper_codegen/src/impl_union.rs

@@ -1,62 +1,25 @@
-use crate::{
-    result::GraphQLScope,
-    util::{self, span_container::SpanContainer},
-};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{ext::IdentExt, spanned::Spanned};
 
-struct ResolverVariant {
-    pub ty: syn::Type,
-    pub resolver: syn::Expr,
-}
-
-struct ResolveBody {
-    pub variants: Vec<ResolverVariant>,
-}
-
-impl syn::parse::Parse for ResolveBody {
-    fn parse(input: syn::parse::ParseStream) -> Result<Self, syn::parse::Error> {
-        input.parse::<syn::token::Match>()?;
-        input.parse::<syn::token::SelfValue>()?;
-
-        let match_body;
-        syn::braced!( match_body in input );
-
-        let mut variants = Vec::new();
-        while !match_body.is_empty() {
-            let ty = match_body.parse::<syn::Type>()?;
-            match_body.parse::<syn::token::FatArrow>()?;
-            let resolver = match_body.parse::<syn::Expr>()?;
+use crate::{
+    result::GraphQLScope,
+    util::{self, span_container::SpanContainer, Mode},
+};
 
-            variants.push(ResolverVariant { ty, resolver });
+const SCOPE: GraphQLScope = GraphQLScope::ImplUnion;
 
-            // Optinal trailing comma.
-            match_body.parse::<syn::token::Comma>().ok();
-        }
+pub fn expand(attrs: TokenStream, body: TokenStream, mode: Mode) -> syn::Result<TokenStream> {
+    let is_internal = matches!(mode, Mode::Internal);
 
-        if !input.is_empty() {
-            return Err(input.error("unexpected input"));
-        }
-
-        Ok(Self { variants })
-    }
-}
-
-pub fn impl_union(
-    is_internal: bool,
-    attrs: TokenStream,
-    body: TokenStream,
-    error: GraphQLScope,
-) -> syn::Result<TokenStream> {
     let body_span = body.span();
     let _impl = util::parse_impl::ImplBlock::parse(attrs, body)?;
 
     // FIXME: what is the purpose of this construct?
     // Validate trait target name, if present.
     if let Some((name, path)) = &_impl.target_trait {
         if !(name == "GraphQLUnion" || name == "juniper.GraphQLUnion") {
-            return Err(error.custom_error(
+            return Err(SCOPE.custom_error(
                 path.span(),
                 "Invalid impl target trait: expected 'GraphQLUnion'",
             ));
@@ -89,7 +52,7 @@ pub fn impl_union(
     let method = match method {
         Some(method) => method,
         None => {
-            return Err(error.custom_error(
+            return Err(SCOPE.custom_error(
                 body_span,
                 "expected exactly one method with signature: fn resolve(&self) { ... }",
             ))
@@ -103,7 +66,7 @@ pub fn impl_union(
     let body = syn::parse::<ResolveBody>(body_raw.into())?;
 
     if body.variants.is_empty() {
-        error.not_empty(method.span())
+        SCOPE.not_empty(method.span())
     }
 
     proc_macro_error::abort_if_dirty();
@@ -221,3 +184,40 @@ pub fn impl_union(
 
     Ok(output.into())
 }
+
+struct ResolverVariant {
+    pub ty: syn::Type,
+    pub resolver: syn::Expr,
+}
+
+struct ResolveBody {
+    pub variants: Vec<ResolverVariant>,
+}
+
+impl syn::parse::Parse for ResolveBody {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self, syn::parse::Error> {
+        input.parse::<syn::token::Match>()?;
+        input.parse::<syn::token::SelfValue>()?;
+
+        let match_body;
+        syn::braced!( match_body in input );
+
+        let mut variants = Vec::new();
+        while !match_body.is_empty() {
+            let ty = match_body.parse::<syn::Type>()?;
+            match_body.parse::<syn::token::FatArrow>()?;
+            let resolver = match_body.parse::<syn::Expr>()?;
+
+            variants.push(ResolverVariant { ty, resolver });
+
+            // Optinal trailing comma.
+            match_body.parse::<syn::token::Comma>().ok();
+        }
+
+        if !input.is_empty() {
+            return Err(input.error("unexpected input"));
+        }
+
+        Ok(Self { variants })
+    }
+}

juniper_codegen/src/lib.rs

@@ -25,6 +25,8 @@ use proc_macro::TokenStream;
 use proc_macro_error::proc_macro_error;
 use result::GraphQLScope;
 
+use self::util::Mode;
+
 #[proc_macro_error]
 #[proc_macro_derive(GraphQLEnum, attributes(graphql))]
 pub fn derive_enum(input: TokenStream) -> TokenStream {
@@ -93,16 +95,6 @@ pub fn derive_object_internal(input: TokenStream) -> TokenStream {
     }
 }
 
-#[proc_macro_error]
-#[proc_macro_derive(GraphQLUnion, attributes(graphql))]
-pub fn derive_union(input: TokenStream) -> TokenStream {
-    let ast = syn::parse::<syn::DeriveInput>(input).unwrap();
-    let gen = derive_union::build_derive_union(ast, false, GraphQLScope::DeriveUnion);
-    match gen {
-        Ok(gen) => gen.into(),
-        Err(err) => proc_macro_error::abort!(err),
-    }
-}
 /// This custom derive macro implements the #[derive(GraphQLScalarValue)]
 /// derive.
 ///
@@ -554,27 +546,36 @@ pub fn graphql_subscription_internal(args: TokenStream, input: TokenStream) -> T
     ))
 }
 
+#[proc_macro_error]
+#[proc_macro_derive(GraphQLUnion, attributes(graphql))]
+pub fn derive_union(input: TokenStream) -> TokenStream {
+    derive_union::expand(input.into(), Mode::Public)
+        .unwrap_or_else(|e| proc_macro_error::abort!(e))
+        .into()
+}
+
+#[proc_macro_error]
+#[proc_macro_derive(GraphQLUnionInternal, attributes(graphql))]
+#[doc(hidden)]
+pub fn derive_union_internal(input: TokenStream) -> TokenStream {
+    derive_union::expand(input.into(), Mode::Internal)
+        .unwrap_or_else(|e| proc_macro_error::abort!(e))
+        .into()
+}
+
 #[proc_macro_error]
 #[proc_macro_attribute]
 pub fn graphql_union(attrs: TokenStream, body: TokenStream) -> TokenStream {
-    let attrs = proc_macro2::TokenStream::from(attrs);
-    let body = proc_macro2::TokenStream::from(body);
-    let gen = impl_union::impl_union(false, attrs, body, GraphQLScope::ImplUnion);
-    match gen {
-        Ok(gen) => gen.into(),
-        Err(err) => proc_macro_error::abort!(err),
-    }
+    impl_union::expand(attrs.into(), body.into(), Mode::Public)
+        .unwrap_or_else(|e| proc_macro_error::abort!(e))
+        .into()
 }
 
 #[proc_macro_error]
 #[proc_macro_attribute]
 #[doc(hidden)]
 pub fn graphql_union_internal(attrs: TokenStream, body: TokenStream) -> TokenStream {
-    let attrs = proc_macro2::TokenStream::from(attrs);
-    let body = proc_macro2::TokenStream::from(body);
-    let gen = impl_union::impl_union(true, attrs, body, GraphQLScope::ImplUnion);
-    match gen {
-        Ok(gen) => gen.into(),
-        Err(err) => proc_macro_error::abort!(err),
-    }
+    impl_union::expand(attrs.into(), body.into(), Mode::Internal)
+        .unwrap_or_else(|e| proc_macro_error::abort!(e))
+        .into()
 }