Change interfaces to require enums

async-graphql-derive/src/interface.rs

@@ -6,26 +6,25 @@ use inflector::Inflector;
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::quote;
+use std::collections::HashSet;
 use syn::{Data, DeriveInput, Error, Fields, Result, Type};
 
 pub fn generate(interface_args: &args::Interface, input: &DeriveInput) -> Result<TokenStream> {
     let crate_name = get_crate_name(interface_args.internal);
     let ident = &input.ident;
     let generics = &input.generics;
-    let attrs = &input.attrs;
-    let vis = &input.vis;
     let s = match &input.data {
-        Data::Struct(s) => s,
+        Data::Enum(s) => s,
-        _ => return Err(Error::new_spanned(input, "It should be a struct.")),
+        _ => {
-    };
+            return Err(Error::new_spanned(
-    let fields = match &s.fields {
+                input,
-        Fields::Unnamed(fields) => Some(&fields.unnamed),
+                "Interfaces can only be applied to an enum.",
-        Fields::Unit => None,
+            ))
-        _ => return Err(Error::new_spanned(input, "All fields must be unnamed.")),
+        }
     };
     let extends = interface_args.extends;
     let mut enum_names = Vec::new();
-    let mut enum_items = Vec::new();
+    let mut enum_items = HashSet::new();
     let mut type_into_impls = Vec::new();
     let gql_typename = interface_args
         .name
@@ -45,11 +44,38 @@ pub fn generate(interface_args: &args::Interface, input: &DeriveInput) -> Result
     let mut collect_inline_fields = Vec::new();
     let mut get_introspection_typename = Vec::new();
 
-    if let Some(fields) = fields {
+    for variant in s.variants.iter() {
-        for field in fields {
+        let enum_name = &variant.ident;
+        let field = match &variant.fields {
+            Fields::Unnamed(fields) if fields.unnamed.len() == 1 => fields.unnamed.first().unwrap(),
+            Fields::Unnamed(_) => {
+                return Err(Error::new_spanned(
+                    variant,
+                    "Only single value variants are supported",
+                ))
+            }
+            Fields::Unit => {
+                return Err(Error::new_spanned(
+                    variant,
+                    "Empty variants are not supported",
+                ))
+            }
+            Fields::Named(_) => {
+                return Err(Error::new_spanned(
+                    variant,
+                    "Variants with named fields are not supported",
+                ))
+            }
+        };
         if let Type::Path(p) = &field.ty {
-                let enum_name = &p.path.segments.last().unwrap().ident;
+            // This validates that the field type wasn't already used
-                enum_items.push(quote! { #enum_name(#p) });
+            if enum_items.insert(p) == false {
+                return Err(Error::new_spanned(
+                    field,
+                    "This type already used in another variant",
+                ));
+            }
+
             type_into_impls.push(quote! {
                 impl #generics From<#p> for #ident #generics {
                     fn from(obj: #p) -> Self {
@@ -81,7 +107,6 @@ pub fn generate(interface_args: &args::Interface, input: &DeriveInput) -> Result
             return Err(Error::new_spanned(field, "Invalid type"));
         }
     }
-    }
 
     let mut methods = Vec::new();
     let mut schema_fields = Vec::new();
@@ -236,8 +261,7 @@ pub fn generate(interface_args: &args::Interface, input: &DeriveInput) -> Result
     };
 
     let expanded = quote! {
-        #(#attrs)*
+        #input
-        #vis enum #ident #generics { #(#enum_items),* }
 
         #(#type_into_impls)*