Separate type with colon in assert_fields!

Author: nvzqz

src/assert_fields.rs

@@ -20,7 +20,7 @@
 /// }
 ///
 /// // Always have `val2` regardless of OS
-/// assert_fields!(Ty, val2);
+/// assert_fields!(Ty: val2);
 /// ```
 ///
 /// This macro even works with `enum` variants:
@@ -36,7 +36,7 @@
 ///     Ptr(*const u8),
 /// }
 ///
-/// assert_fields!(Data::Val, id, bytes);
+/// assert_fields!(Data::Val: id, bytes);
 /// ```
 ///
 /// The following example fails to compile because [`Range`] does not have a field named `middle`:
@@ -45,13 +45,13 @@
 /// # #[macro_use] extern crate static_assertions; fn main() {}
 /// use std::ops::Range;
 ///
-/// assert_fields!(Range<u32>, middle);
+/// assert_fields!(Range<u32>: middle);
 /// ```
 ///
 /// [`Range`]: https://doc.rust-lang.org/std/ops/struct.Range.html
 #[macro_export]
 macro_rules! assert_fields {
-    ($t:ident::$v:ident, $($f:ident),+) => {
+    ($t:ident::$v:ident: $($f:ident),+) => {
         #[allow(unknown_lints, unneeded_field_pattern)]
         const _: fn() = || {
             #[allow(dead_code, unreachable_patterns)]
@@ -63,7 +63,7 @@ macro_rules! assert_fields {
             }
         };
     };
-    ($t:path, $($f:ident),+) => {
+    ($t:path: $($f:ident),+) => {
         #[allow(unknown_lints, unneeded_field_pattern)]
         const _: fn() = || {
             $(let $t { $f: _, .. };)+

tests/fields.rs

@@ -4,25 +4,26 @@
 #[macro_use]
 extern crate static_assertions;
 
-mod m {
-    pub struct _Struct<T: ?Sized> { pub nul: (), pub inner: T }
-}
-
-use m::_Struct as _Reused;
-
 #[allow(dead_code)]
-enum _Thing {
+enum Foo {
     A { x: u8, y: u8 },
     B(u8),
 }
 
-assert_fields!(m::_Struct<str>, inner, nul);
+assert_fields!(Foo::A: x);
+assert_fields!(Foo::A: x, x);
+assert_fields!(Foo::A: x, y, x);
+
+// TODO: Make tuple field access possible
+// assert_fields!(Foo::B, 0);
 
-assert_fields!(_Reused<dyn Send>, inner);
+mod m {
+    #[allow(dead_code)]
+    pub struct Bar<T: ?Sized> { pub nul: (), pub inner: T }
+}
 
-assert_fields!(_Thing::A, x);
-assert_fields!(_Thing::A, x, x);
-assert_fields!(_Thing::A, x, y, x);
+#[allow(dead_code)]
+use m::Bar as Baz;
 
-// TODO: Make tuple field access possible
-// assert_fields!(_Thing::B, 0);
+assert_fields!(m::Bar<str>: inner, nul);
+assert_fields!(Baz<dyn Send>: inner, nul);