Use fully-qualified path to refer to the associated type

Prevent "ambiguous associated type" if one of the variants is named `Numeric`.

Author: LukeMathWalker

enumflags_derive/src/lib.rs

@@ -9,7 +9,7 @@ use syn::{
     parse::{Parse, ParseStream},
     parse_macro_input,
     spanned::Spanned,
-    Expr, Ident, DeriveInput, Data, Token, Variant,
+    Data, DeriveInput, Expr, Ident, Token, Variant,
 };
 
 struct Flag<'a> {
@@ -249,18 +249,24 @@ fn gen_enumflags(ast: &mut DeriveInput, default: Vec<Ident>) -> Result<TokenStre
     let ast_variants = match &mut ast.data {
         Data::Enum(ref mut data) => &mut data.variants,
         Data::Struct(data) => {
-            return Err(syn::Error::new_spanned(&data.struct_token,
-                "expected enum for #[bitflags], found struct"));
+            return Err(syn::Error::new_spanned(
+                &data.struct_token,
+                "expected enum for #[bitflags], found struct",
+            ));
         }
         Data::Union(data) => {
-            return Err(syn::Error::new_spanned(&data.union_token,
-                "expected enum for #[bitflags], found union"));
+            return Err(syn::Error::new_spanned(
+                &data.union_token,
+                "expected enum for #[bitflags], found union",
+            ));
         }
     };
 
     if ast.generics.lt_token.is_some() || ast.generics.where_clause.is_some() {
-        return Err(syn::Error::new_spanned(&ast.generics,
-            "bitflags cannot be generic"));
+        return Err(syn::Error::new_spanned(
+            &ast.generics,
+            "bitflags cannot be generic",
+        ));
     }
 
     let repr = extract_repr(&ast.attrs)?
@@ -334,18 +340,18 @@ fn gen_enumflags(ast: &mut DeriveInput, default: Vec<Ident>) -> Result<TokenStre
             unsafe impl ::enumflags2::_internal::RawBitFlags for #ident {
                 type Numeric = #repr;
 
-                const EMPTY: Self::Numeric = 0;
+                const EMPTY: <Self as ::enumflags2::_internal::RawBitFlags>::Numeric = 0;
 
-                const DEFAULT: Self::Numeric =
+                const DEFAULT: <Self as ::enumflags2::_internal::RawBitFlags>::Numeric =
                     0 #(| (Self::#default as #repr))*;
 
-                const ALL_BITS: Self::Numeric =
+                const ALL_BITS: <Self as ::enumflags2::_internal::RawBitFlags>::Numeric =
                     0 #(| (Self::#variant_names as #repr))*;
 
                 const BITFLAGS_TYPE_NAME : &'static str =
                     concat!("BitFlags<", stringify!(#ident), ">");
 
-                fn bits(self) -> Self::Numeric {
+                fn bits(self) -> <Self as ::enumflags2::_internal::RawBitFlags>::Numeric {
                     self as #repr
                 }
             }

test_suite/common.rs

@@ -29,6 +29,14 @@ enum Default6 {
     D = 1 << 3,
 }
 
+#[bitflags]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[repr(u8)]
+enum AssociatedTypeNameConflict {
+    Stringy = 1 << 0,
+    Numeric = 1 << 1,
+}
+
 #[test]
 fn test_ctors() {
     use enumflags2::BitFlags;
@@ -109,7 +117,10 @@ fn iterator() {
     ];
 
     for &(bitflag, expected) in tests {
-        assert!(bitflag.iter().zip(expected.iter().copied()).all(|(a, b)| a == b));
+        assert!(bitflag
+            .iter()
+            .zip(expected.iter().copied())
+            .all(|(a, b)| a == b));
         // If cloned, the iterator will yield the same elements.
         let it = bitflag.iter();
         assert!(it.clone().zip(it).all(|(a, b)| a == b));