Derive Clone when deriving Copy

[dimbleby]

bindgen almost always implements Clone explicitly, like this:

impl Clone for Foo {
    fn clone(&self) -> Self { *self }
}

I (accidentally!) ran clippy over some autogenerated code and it expressed disappointment that Clone was manually implemented for all sorts of structures on which Copy was derived:

warning: you are implementing `Clone` explicitly on a `Copy` type

And indeed, Clone could be derived in every case, at least for my project.

The code that prevents this is here.

My input header is a plain C header (so certainly no templates). If anything, it almost looks as though that test is exactly backwards, though I expect it's more likely that I simply don't understand what issue is being avoided here...

Anyway, it certainly seems like Clone could be derived a lot more often than it currently is.

[emilio]

This is pretty much intentional, because of large arrays, which implement Copy but not Clone. I'm not sure it's worth to add the complexity to derive it when possible tbh.

[dimbleby]

Well, certainly this is at worst a wart rather than a bug. I don't really expect auto-generated code to be clean under clippy. (But wouldn't it be nice if it were?).

Compared to the work you must already do figuring out when all the other derived things are derivable, I'd have guessed that "is there a big array involved?" was a relatively straightforward check... but that's absolutely a guess from ignorance, and I'm happy to be contradicted by someone who actually knows what they're talking about!

So yeah, I'm content to defer to maintainer judgement here. If you think that the effort / reward ratio for this one will never be worthwhile, please just close it out.

[fitzgen]

This is pretty much intentional, because of large arrays, which implement Copy but not Clone. I'm not sure it's worth to add the complexity to derive it when possible tbh.

Is this the only case where we end up manually implementing Clone? The source comments look like it has more to do with type parameters.

[dimbleby]

Is this the only case where we end up manually implementing Clone?

No: Clone is manually implemented nearly always so far as I can tell, even when no arrays (large or otherwise) are involved.

[fitzgen]

Huh. This doesn't sound right. It seems like I don't have the full picture here, and we need some more investigation.

[dimbleby]

IIUC, as of Rust 1.21 and rust-lang/rust#43690, large arrays should no longer be an issue when deriving Clone.

• [T; N] is now Clone if T: Clone (currently, only if T: Copy and for N <= 32).

[fitzgen]

Awesome :)

We will need to add a new RustTarget for 1.21 and take that into account in our analyses/codegen.