Macro fails to generate generic implementation unless it is with ident

[uzytkownik]

I've tried several ways but it looks like the only way is to 'smuggle' the ops by using ident. It seems that macros should be able to stuck path with generic arguments as idents seems counterintuitive.

macro_rules! gen_impl1 {
    ($trt:path, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        impl $trt<$arg> for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    };
}

macro_rules! gen_impl2 {
    ($trt:tt, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        impl $trt<$arg> for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    };
}

macro_rules! gen_impl3 {
    ($trt:path, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        gen_impl3!([$trt<$arg>], $fr, $o, $f);
    };
    ([$($trt:tt)*], $fr:ty, $o:ty, $f:ident) => {
        impl $($trt)* for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    };
}

macro_rules! gen_impl4 {
    ($trt:path, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        gen_impl3!($trt<$arg>, $fr, $o, $f);
    };
    ($trt:ty, $fr:ty, $o:ty, $f:ident) => {
        impl $trt for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    };
}

macro_rules! gen_impl5 {
    ($($trt:ident)::*, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        impl $($trt)::*<$arg> for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    }
}

macro_rules! gen_impl_ident {
    ($trt:ident, $arg:ty, $fr:ty, $o:ty, $f:ident) => {
        impl $trt<$arg> for $fr {
            type Output = $o;
            fn $f(self, rhs: $arg) -> Self::Output {
                loop {}
            }
        }
    };
}

struct Foo;
struct Bar;
struct FooBar;

// Those fails with: no rules expected the token `<`
gen_impl1!(std::ops::Add, Foo, Bar, FooBar, add);
gen_impl2!(std::ops::Add, Foo, Bar, FooBar, add);
gen_impl3!(std::ops::Add, Foo, Bar, FooBar, add);
gen_impl4!(std::ops::Add, Foo, Bar, FooBar, add);

// This works
gen_impl5!(std::ops::Add, Foo, Bar, FooBar, add);
use std::ops::Add;
gen_impl_ident!(Add, Foo, Bar, FooBar, add);

[petrochenkov]

So the idea is to take an arbitrary path a::b::c and attach an <arg> to the end of it?
That's indeed not allowed because something like a::b::c<xxx> is already a path and after attaching <arg> it becomes a::b::c<xxx><arg>, which is not a correct path.

For this reason you have to assemble the path manually and something like gen_impl5 looks like the correct approach.
(Except that + is preferable to *, with * the macro will accept something like gen_impl5!(, Foo, Bar, FooBar, add);)