stages! macro doesn't work without trailing comma

[Anders429]

Came across this today. With the trailing comma, it compiles just fine, but without the comma it seems to not be resolving the macro properly, complaining about a @ character being present.

[Anders429]

Seems this doesn't happen with flush commands, but it does happen with system commands. For example,

#[derive(Clone)]
struct A(f32);
#[derive(Clone)]
struct B(f32);
#[derive(Clone)]
struct C(f32);
#[derive(Clone)]
struct D(f32);
#[derive(Clone)]
struct E(f32);

type Registry = registry!(A, B, C, D, E);

struct AB;

impl<'a> System<'a> for AB {
    type Views = views!(&'a mut A, &'a mut B);
    type Filter = filter::None;

    fn run<R, FI, VI, P, I, Q>(
        &mut self,
        query_results: result::Iter<'a, R, Self::Filter, FI, Self::Views, VI, P, I, Q>,
    ) where
        R: ContainsQuery<'a, Self::Filter, FI, Self::Views, VI, P, I, Q> + 'a,
    {
        for result!(a, b) in query_results {
            core::mem::swap(&mut a.0, &mut b.0);
        }
    }
}

struct CD;

impl<'a> System<'a> for CD {
    type Views = views!(&'a mut C, &'a mut D);
    type Filter = filter::None;

    fn run<R, FI, VI, P, I, Q>(
        &mut self,
        query_results: result::Iter<'a, R, Self::Filter, FI, Self::Views, VI, P, I, Q>,
    ) where
        R: ContainsQuery<'a, Self::Filter, FI, Self::Views, VI, P, I, Q> + 'a,
    {
        for result!(c, d) in query_results {
            core::mem::swap(&mut c.0, &mut d.0);
        }
    }
}

struct CE;

impl<'a> System<'a> for CE {
    type Views = views!(&'a mut C, &'a mut E);
    type Filter = filter::None;

    fn run<R, FI, VI, P, I, Q>(
        &mut self,
        query_results: result::Iter<'a, R, Self::Filter, FI, Self::Views, VI, P, I, Q>,
    ) where
        R: ContainsQuery<'a, Self::Filter, FI, Self::Views, VI, P, I, Q> + 'a,
    {
        for result!(c, e) in query_results {
            core::mem::swap(&mut c.0, &mut e.0);
        }
    }
}

type Stages = stages!(
    system: AB,
    system: CD,
    system: CE
);

does not compile, but adding the comma after CE does compile.

[Anders429]

Turns out a ! character was missing from the macro definition on this line.