Add a derive! macro to utilise deriving sugar outside Struct/Enum definition

[bharrisau]

Not sure if this is the correct solution, but I'm looking at untangling libstd so it can be built freestanding.

The deriving syntax is good, but if you want to make part of it conditional you can't. Looking at #11968, Eq and Clone have to be done with the impl written out in full, be easier to do

derive!(marker::CovariantType<T>, (Eq, Clone))

And if libprim is replaced with #[cfg] tags, you can do

#[lang="covariant_type"]
pub struct CovariantType<T>;

#[cfg(with_alloc)] derive!(CovariantType<T>, (Eq, Clone))

Or maybe these should just be written out in full?

[pnkfelix]

This is an interesting idea, but I suspect that the reason that deriving! has to occur where it does in the syntax (immediately above the definition of the item in question) is that the macro machinery does not have the ability to resolve a path. (That is, macro expansion occurs before the resolve step, I think.)

E.g. in your example of derive!(marker::CovariantType<T>, (Eq, Clone)) it does not have the ability to resolve marker::CovariantType<T> to its definition (which it needs to expand into the desired impl being derived).

I'll leave this open because I think some discussion might come up on how else to deal with cfg-conditional derived impls.

[sfackler]

@pnkfelix is correct.

[lifthrasiir]

Some notes: If the conditional attribute is the only concern here, one can use the following macro tricks:

macro_rules! define_CovariantType(
    ($($a:attr)*) => (
        #[lang="covariant_type"]
        $($a)*
        pub struct CovariantType<T>;
    )
)

#[cfg(with_alloc)] define_CovariantType!(#[deriving(Eq,Clone)])
#[cfg(not(with_alloc))] define_CovariantType!()

[bharrisau]

The other case this might have been useful is impl for objects defined in another crate and re-exported (e.g. prim). Pity is isn't going to work.

mod foo {
  struct Bar {
    ....
  }
}

pub use foo:Bar;

derive!(Bar, (Clone))