Macro compilation tests.

.github/workflows/test.yaml

@@ -136,12 +136,21 @@ jobs:
         args: miri test --feature-powerset --optional-deps
       env:
         MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-ignore-leaks
+        RUSTFLAGS: --cfg skip_trybuild
 
   valgrind:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - run: sudo apt-get install valgrind
+    - run: wget https://sourceware.org/pub/valgrind/valgrind-3.18.1.tar.bz2
+    - run: tar xvf valgrind-3.18.1.tar.bz2
+    - run: ./configure
+      working-directory: ./valgrind-3.18.1
+    - run: make
+      working-directory: ./valgrind-3.18.1
+    - run: sudo make install
+      working-directory: ./valgrind-3.18.1
+    - run: sudo apt-get install libc6-dbg
     - uses: actions-rs/toolchain@v1
       with:
         toolchain: nightly
@@ -156,6 +165,8 @@ jobs:
       with:
         command: hack
         args: valgrind test --feature-powerset --optional-deps
+      env:
+        RUSTFLAGS: --cfg skip_trybuild
 
   codecov:
     runs-on: ubuntu-latest

Cargo.toml

@@ -18,7 +18,9 @@ rayon = {version = "1.5.1", optional = true}
 serde = {version = "1.0.133", default-features = false, features = ["alloc"], optional = true}
 
 [dev-dependencies]
+rustversion = "1.0.6"
 serde_test = "1.0.133"
+trybuild = "1.0.56"
 
 [features]
 # TODO: Rename this to "rayon" when namespaced dependencies are stabilized in 1.60.0.

src/entities/mod.rs

@@ -227,10 +227,10 @@ macro_rules! entities {
             )
         }
     };
-    ($(($($components:expr),*)),* $(,)?) => {
+    ($(($($components:expr),*)),+ $(,)?) => {
         unsafe {
             $crate::entities::Batch::new_unchecked(
-                $crate::entities!(@transpose [] $(($($components),*)),*)
+                $crate::entities!(@transpose [] $(($($components),*)),+)
             )
         }
     };
@@ -244,18 +244,21 @@ macro_rules! entities {
             $crate::entities::Batch::new_unchecked($crate::entities::Null)
         }
     };
+
     (@cloned ($component:expr $(,$components:expr)* $(,)?); $n:expr) => {
         ($crate::reexports::vec![$component; $n], $crate::entities!(@cloned ($($components),*); $n))
     };
     (@cloned (); $n:expr) => {
         $crate::entities::Null
     };
+
     (@transpose [$([$($column:expr),*])*] $(($component:expr $(,$components:expr)*  $(,)?)),*) => {
         $crate::entities!(@transpose [$([$($column),*])* [$($component),*]] $(($($components),*)),*)
     };
     (@transpose [$([$($column:expr),*])*] $(()),*) => {
         $crate::entities!(@as_vec ($(($($column),*)),*))
     };
+
     (@as_vec (($($column:expr),*) $(,($($columns:expr),*))* $(,)?)) => {
         ($crate::reexports::vec![$($column),*], $crate::entities!(@as_vec ($(($($columns),*)),*)))
     };

src/lib.rs

@@ -18,6 +18,7 @@ mod archetype;
 mod archetypes;
 mod doc;
 mod hlist;
+mod r#macro;
 
 #[doc(inline)]
 pub use world::World;

src/macro.rs

@@ -0,0 +1,16 @@
+//! Helper macros specifically for use by other macros within this crate.
+//!
+//! Although the macros here are exported publicly, it is only for use by other macros within this
+//! crate. These should not be depended upon by any external code, and are not considered a part of
+//! the public API.
+
+/// Indicate that the given tokens were unexpected.
+///
+/// Calling this macro with any tokens will return an error pointing to those tokens within the
+/// original macro. This allows more precise error messages from macros when input is not formatted
+/// correctly.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! unexpected {
+    () => {};
+}

src/system/schedule/stage/mod.rs

@@ -115,20 +115,159 @@ doc::non_root_macro! {
     /// [`schedule::Builder`]: crate::system::schedule::Builder
     /// [`System`]: crate::system::System
     macro_rules! stages {
-        ($($idents:tt $(: $systems:tt)?),* $(,)?) => (
-            stages!(internal @ $crate::system::schedule::stage::Null; $($idents $(: $systems)?,)*)
-        );
-        (internal @ $processed:ty; system: $system:ty, $($idents:tt $(: $systems:tt)?),* $(,)?) => (
-            stages!(internal @ ($crate::system::schedule::stage::Stage<$system, $crate::system::Null>, $processed); $($idents $(: $systems)?,)*)
-        );
-        (internal @ $processed:ty; par_system: $par_system:ty, $($idents:tt $(: $systems:tt)?),* $(,)?) => (
-            stages!(internal @ ($crate::system::schedule::stage::Stage<$crate::system::Null, $par_system>, $processed); $($idents $(: $systems)?,)*)
-        );
-        (internal @ $processed:ty; flush, $($idents:tt $(: $systems:tt)?),* $(,)?) => (
-            stages!(internal @ ($crate::system::schedule::stage::Stage<$crate::system::Null, $crate::system::Null>, $processed); $($idents $(: $systems)?,)*)
-        );
-        (internal @ $processed:ty; $($idents:tt $(: $systems:tt)?),* $(,)?) => (
-            $processed
+        // Entry point for the macro.
+        //
+        // This just calls into the internal macro with all of the correct parameters.
+        ($($tt:tt)*) => (
+            $crate::stages_internal!(@task $crate::system::schedule::stage::Null; ($($tt)*) ($($tt)*))
         );
     }
 }
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! stages_internal {
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Generic task macro.
+    //
+    // These patterns are for matching and processing generic tasks listed in the token tree. When
+    // each of the valid task types (system, par_system, and flush) are encountered, the tokens are
+    // passed to the appropriate patterns (@system, @par_system, and @flush) to be consumed.
+    //
+    // Note that we require two copies of the input token tree here. The first is matched on, and
+    // the second is used to trigger errors.
+    //
+    // Invoked as:
+    // $crate::stages_internal!(@task $crate::system::schedule::stage::Null; ($($tt)*) ($($tt)*))
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+
+    // Match a system task.
+    (@task $processed:ty; (system $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@system $processed; ($($rest)*) ($($rest)*))
+    );
+
+    // Match a par_system task.
+    (@task $processed:ty; (par_system $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@par_system $processed; ($($rest)*) ($($rest)*))
+    );
+
+    // Match a flush task.
+    (@task $processed:ty; (flush $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@flush $processed; ($($rest)*) ($($rest)*))
+    );
+
+    // End case. We return the processed result.
+    (@task $processed:ty; () ()) => (
+        $processed
+    );
+
+    // Match any other unexpected input. This will output an error.
+    (@task $processed:ty; ($($rest:tt)*) $copy:tt) => (
+        $crate::unexpected!($($rest)*)
+    );
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // System task macro.
+    //
+    // These patterns match the remainder of a system task entry. This will match a colon followed
+    // by a system type. Trailing commas are also matched here.
+    //
+    // Note that we require two copies of the input token tree here. The first is matched on, and
+    // the second is used to trigger errors.
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+
+    // Match a system type without a trailing comma. This will only match at the end of the token
+    // tree.
+    (@system $processed:ty; (: $system:ty) $copy:tt) => {
+        $crate::stages_internal(@task ($crate::system::schedule::stage::Stage<$system, $crate::system::Null>, $processed); () ())
+    };
+
+    // Match a system type with a trailing comma.
+    (@system $processed:ty; (: $system:ty, $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@task ($crate::system::schedule::stage::Stage<$system, $crate::system::Null>, $processed); ($($rest)*) ($($rest)*))
+    );
+
+    // Match a system type with no trailing comma not at the end of the token tree. This will
+    // output an error.
+    (@system $processed:ty; (: $system:tt $($rest:tt)*) $copy:tt) => {
+        $crate::unexpected!($($rest)*)
+    };
+
+    // Match a comma with no system type provided. This will output an error.
+    (@system $processed:ty; (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => (
+        $crate::unexpected!($comma)
+    );
+
+    // Match any other unexpected input. This will output an error.
+    (@system $processed:ty; ($($rest:tt)*) $copy:tt) => (
+        $crate::unexpected!($($rest)*)
+    );
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Parallel system task macro.
+    //
+    // These patterns match the remainder of a par_system task entry. This will match a colon
+    // followed by a parallel system type. Trailing commas are also matched here.
+    //
+    // Note that we require two copies of the input token tree here. The first is matched on, and
+    // the second is used to trigger errors.
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+
+    // Match a parallel system type without a trailing comma. This will only match at the end of
+    // the token tree.
+    (@par_system $processed:ty; (: $par_system:ty) $copy:tt) => (
+        $crate::stages_internal!(@task ($crate::system::schedule::stage::Stage<$crate::system::Null, $par_system>, $processed); () ())
+    );
+
+    // Match a parallel system type with a trailing comma.
+    (@par_system $processed:ty; (: $par_system:ty, $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@task ($crate::system::schedule::stage::Stage<$crate::system::Null, $par_system>, $processed); ($($rest)*) ($($rest)*))
+    );
+
+    // Match a parallel system type with no trailing comma not at the end of the token tree. This
+    // will output an error.
+    (@par_system $processed:ty; (: $par_system:tt $($rest:tt)*) $copy:tt) => {
+        $crate::unexpected!($($rest)*)
+    };
+
+    // Match a comma with no parallel system type provided. This will output an error.
+    (@par_system $processed:ty; (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => (
+        $crate::unexpected!($comma)
+    );
+
+    // Match any other unexpected input. This will output an error.
+    (@par_system $processed:ty; ($($rest:tt)*) $copy:tt) => (
+        $crate::unexpected!($($rest)*)
+    );
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Flush task macro.
+    //
+    // These patterns match the remainder of a flush task entry, which is only either a comma or
+    // nothing.
+    //
+    // Note that we require two copies of the input token tree here. The first is matched on, and
+    // the second is used to trigger errors.
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+
+    // Match a comma.
+    (@flush $processed:ty; (, $($rest:tt)*) $copy:tt) => (
+        $crate::stages_internal!(@task ($crate::system::schedule::stage::Stage<$crate::system::Null, $crate::system::Null>, $processed); ($($rest)*) ($($rest)*))
+    );
+
+    // Match a colon. This is invalid and will output an error.
+    (@flush $processed:ty; (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => (
+        $crate::unexpected!($colon)
+    );
+
+    // Match nothing. This will only occur at the end of the input token tree, which is the only
+    // time when a trailing comma is not required.
+    (@flush $processed:ty; () ()) => (
+        $crate::stages_internal!(@task ($crate::system::schedule::stage::Stage<$crate::system::Null, $crate::system::Null>, $processed); () ())
+    );
+
+    // Match any other unexpected input. This will output an error.
+    (@flush $processed:ty; ($($rest:tt)*) $copy:tt) => (
+        $crate::unexpected!($($rest)*)
+    );
+}

tests/trybuild.rs

@@ -0,0 +1,23 @@
+#![cfg(not(skip_trybuild))]
+
+macro_rules! trybuild_test {
+    ($test_name:ident) => {
+        #[test]
+        #[rustversion::attr(not(nightly), ignore)]
+        fn $test_name() {
+            trybuild::TestCases::new().compile_fail(concat!(
+                "tests/trybuild/",
+                stringify!($test_name),
+                "/*.rs"
+            ));
+        }
+    };
+}
+
+trybuild_test!(entities);
+trybuild_test!(entity);
+trybuild_test!(registry);
+trybuild_test!(result);
+#[cfg(feature = "parallel")]
+trybuild_test!(stages);
+trybuild_test!(views);

tests/trybuild/entities/comma_alone.rs

@@ -0,0 +1,5 @@
+use brood::entities;
+
+fn main () {
+    let entities = entities!(,);
+}

tests/trybuild/entities/comma_alone.stderr

@@ -0,0 +1,5 @@
+error: no rules expected the token `,`
+ --> tests/trybuild/entities/comma_alone.rs:4:30
+  |
+4 |     let entities = entities!(,);
+  |                              ^ no rules expected this token in macro call

tests/trybuild/entities/component_order.rs

@@ -0,0 +1,9 @@
+use brood::entities;
+
+// Define components.
+struct A;
+struct B;
+
+fn main () {
+    let entities = entities!((A, B), (B, A));
+}

tests/trybuild/entities/component_order.stderr

@@ -0,0 +1,11 @@
+error[E0308]: mismatched types
+ --> tests/trybuild/entities/component_order.rs:8:39
+  |
+8 |     let entities = entities!((A, B), (B, A));
+  |                                       ^ expected struct `A`, found struct `B`
+
+error[E0308]: mismatched types
+ --> tests/trybuild/entities/component_order.rs:8:42
+  |
+8 |     let entities = entities!((A, B), (B, A));
+  |                                          ^ expected struct `B`, found struct `A`

tests/trybuild/entities/double_comma.rs

@@ -0,0 +1,9 @@
+use brood::entities;
+
+// Define components.
+struct A;
+struct B;
+
+fn main () {
+    let entities = entities!((A, B),, (A, B));
+}

tests/trybuild/entities/double_comma.stderr

@@ -0,0 +1,5 @@
+error: no rules expected the token `,`
+ --> tests/trybuild/entities/double_comma.rs:8:37
+  |
+8 |     let entities = entities!((A, B),, (A, B));
+  |                                     ^ no rules expected this token in macro call

tests/trybuild/entities/length_not_integer.rs

@@ -0,0 +1,11 @@
+use brood::entities;
+
+// Define components.
+#[derive(Clone)]
+struct A;
+#[derive(Clone)]
+struct B;
+
+fn main () {
+    let entities = entities!((A, B); 1.5);
+}

tests/trybuild/entities/length_not_integer.stderr

@@ -0,0 +1,5 @@
+error[E0308]: mismatched types
+  --> tests/trybuild/entities/length_not_integer.rs:10:38
+   |
+10 |     let entities = entities!((A, B); 1.5);
+   |                                      ^^^ expected `usize`, found floating-point number

tests/trybuild/entities/same_components.rs

@@ -0,0 +1,10 @@
+use brood::entities;
+
+// Define components.
+struct A;
+struct B;
+struct C;
+
+fn main () {
+    let entities = entities!((A, B), (A, C));
+}

tests/trybuild/entities/same_components.stderr

@@ -0,0 +1,5 @@
+error[E0308]: mismatched types
+ --> tests/trybuild/entities/same_components.rs:9:42
+  |
+9 |     let entities = entities!((A, B), (A, C));
+  |                                          ^ expected struct `B`, found struct `C`

tests/trybuild/entities/semicolon_separated.rs

@@ -0,0 +1,11 @@
+use brood::entities;
+
+// Define components.
+#[derive(Clone)]
+struct A;
+#[derive(Clone)]
+struct B;
+
+fn main () {
+    let entities = entities!((A, B); (A, B); (A, B));
+}