Cannot derrive Clone for empty enums when using no_std

[Roxxik]

derriving clone on an empty enum does not work without std, because it calls core::rt::begin_unwind:

#![no_std]

#[derive(Copy, Clone)]
enum MyEnum { }

leads to:

<anon>:4:16: 4:21 error: failed to resolve. Could not find `rt` in `core` [E0433]
<anon>:4 #[derive(Copy, Clone)]
                        ^~~~~
<anon>:4:16: 4:21 note: in this expansion of #[derive_Clone] (defined in <anon>)
<anon>:4:16: 4:21 help: see the detailed explanation for E0433
<anon>:4:16: 4:21 error: unresolved name `core::rt::begin_unwind` [E0425]
<anon>:4 #[derive(Copy, Clone)]
                        ^~~~~
<anon>:4:16: 4:21 note: in this expansion of #[derive_Clone] (defined in <anon>)
<anon>:4:16: 4:21 help: see the detailed explanation for E0425
error: main function not found
error: aborting due to 3 previous errors

Playground: https://play.rust-lang.org/?gist=7f786db03eca51a39900&version=nightly

[ticki]

Related: #29548

[durka]

This is actually common to all derives, and the bug is that when generating a panic expression, it hardcodes std::rt::begin_unwind which gets automatically changed to core::rt::begin_unwind when #![no_std] is in effect. Perhaps it should generate a call to the actual panic!() macro instead? I'm not sure if macros can still be expanded at the point where this is generated.

[alexcrichton]

Oh wow now that's just crazy (calling some runtime panic function..)

I think this would be more appropriate to perhaps derive as:

impl Clone for MyEnum {
    fn clone(&self) -> MyEnum {
        match *self {}
    }
}

[durka]

@alexcrichton it could equivalently call intrinsics::unreachable() as it does in another part of the expansion... it does change the behavior of unsafe code (transmute::<_, MyEnum>(()).clone() triggers UB instead of panicking) but it's probably the right thing to do.

[alexcrichton]

Perhaps, but using match *self {} has 0 dependencies on any API for any crate you're linking to, and should in general just be more robust

[durka]

@alexcrichton as far as I can tell this is the only in-tree usage of syntax::ext::build::expr_unreachable and syntax::ext::build::expr_fail, and that's where the call to std/core::rt::begin_unwind is generated -- do you think it makes sense to change those functions (which are going to be broken on #![no_std] as in this issue), or leave them for dead and generate match *self {} from the #[derive] expander?

[alexcrichton]

Hm, in theory we should just never call those functions. In contexts with empty enums they never exist so they shouldn't even panic, I'm not sure about others though.

[bluss]

Generating match *self {} is simple and correct (it's safe Rust), but the same derive code is also used for n-ary match clauses, specifically for PartialEq and so on, where it generates match (&*self, &*rhs) { /* multiple cases */ } when there are more than 0 variants.

For that reason, changing it to use intrinsics unreachable may be the simplest. match (*self, *rhs) { /* empty */ } does not compile for void enums.