1 files changed, 21 insertions, 7 deletions

diff --git a/src/ast.rs b/src/ast.rs
index 8698ecf..2aa7246 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -1,4 +1,5 @@
 use crate::attr::{self, Attrs};
+use crate::generics::ParamsInScope;
 use proc_macro2::Span;
 use syn::{
     Data, DataEnum, DataStruct, DeriveInput, Error, Fields, Generics, Ident, Index, Member, Result,
@@ -38,6 +39,7 @@ pub struct Field<'a> {
     pub attrs: Attrs<'a>,
     pub member: Member,
     pub ty: &'a Type,
+    pub contains_generic: bool,
 }
 
 impl<'a> Input<'a> {
@@ -56,8 +58,9 @@ impl<'a> Input<'a> {
 impl<'a> Struct<'a> {
     fn from_syn(node: &'a DeriveInput, data: &'a DataStruct) -> Result<Self> {
         let mut attrs = attr::get(&node.attrs)?;
+        let scope = ParamsInScope::new(&node.generics);
         let span = attrs.span().unwrap_or_else(Span::call_site);
-        let fields = Field::multiple_from_syn(&data.fields, span)?;
+        let fields = Field::multiple_from_syn(&data.fields, &scope, span)?;
         if let Some(display) = &mut attrs.display {
             display.expand_shorthand(&fields);
         }
@@ -74,12 +77,13 @@ impl<'a> Struct<'a> {
 impl<'a> Enum<'a> {
     fn from_syn(node: &'a DeriveInput, data: &'a DataEnum) -> Result<Self> {
         let attrs = attr::get(&node.attrs)?;
+        let scope = ParamsInScope::new(&node.generics);
         let span = attrs.span().unwrap_or_else(Span::call_site);
         let variants = data
             .variants
             .iter()
             .map(|node| {
-                let mut variant = Variant::from_syn(node, span)?;
+                let mut variant = Variant::from_syn(node, &scope, span)?;
                 if let display @ None = &mut variant.attrs.display {
                     *display = attrs.display.clone();
                 }
@@ -102,28 +106,37 @@ impl<'a> Enum<'a> {
 }
 
 impl<'a> Variant<'a> {
-    fn from_syn(node: &'a syn::Variant, span: Span) -> Result<Self> {
+    fn from_syn(node: &'a syn::Variant, scope: &ParamsInScope<'a>, span: Span) -> Result<Self> {
         let attrs = attr::get(&node.attrs)?;
         let span = attrs.span().unwrap_or(span);
         Ok(Variant {
             original: node,
             attrs,
             ident: node.ident.clone(),
-            fields: Field::multiple_from_syn(&node.fields, span)?,
+            fields: Field::multiple_from_syn(&node.fields, scope, span)?,
         })
     }
 }
 
 impl<'a> Field<'a> {
-    fn multiple_from_syn(fields: &'a Fields, span: Span) -> Result<Vec<Self>> {
+    fn multiple_from_syn(
+        fields: &'a Fields,
+        scope: &ParamsInScope<'a>,
+        span: Span,
+    ) -> Result<Vec<Self>> {
         fields
             .iter()
             .enumerate()
-            .map(|(i, field)| Field::from_syn(i, field, span))
+            .map(|(i, field)| Field::from_syn(i, field, scope, span))
             .collect()
     }
 
-    fn from_syn(i: usize, node: &'a syn::Field, span: Span) -> Result<Self> {
+    fn from_syn(
+        i: usize,
+        node: &'a syn::Field,
+        scope: &ParamsInScope<'a>,
+        span: Span,
+    ) -> Result<Self> {
         Ok(Field {
             original: node,
             attrs: attr::get(&node.attrs)?,
@@ -134,6 +147,7 @@ impl<'a> Field<'a> {
                 })
             }),
             ty: &node.ty,
+            contains_generic: scope.intersects(&node.ty),
         })
     }
 }