deriving error should point to field which caused the error

[metajack]

Compiling the following:

struct Foo {
    foo: bool,
}

#[deriving(Clone)]
struct Bar {
    foo: Foo,
}

fn main() {
    let a = Bar { foo: Foo { foo: true }};
    a.clone();
}

produces

clonespan.rs:5:11: 5:16 error: mismatched types: expected `Foo` but found `&Foo` (expected struct Foo but found &-ptr)
clonespan.rs:5 #[deriving(Clone)]
                          ^~~~~

The real error is that Foo doesn't implement Clone. The span should also probably point to Foo in the definition for Bar instead of to the deriving line.

[metajack]

I ran into another case of this error a few days ago. It went something like this:

use std::libc::c_void;

pub type Foo = c_void;

#[deriving(Clone)]
struct Bar {
  priv foo: *Foo,
}

Maybe this is just a missing Clone impl for raw pointers. Or perhaps this pattern is specifically not supported. I didn't have time to look but figured I'd update this bug.

[emberian]

This is going to be hard, I think. But, maybe not. Perhaps the deriving could rewrite the span to the originating field?

cc @huonw

[huonw]

It shouldn't be too hard; I'll look at it tonight.

[huonw]

(I have looked at it, I've got a patch compiling, but it'll take me a day or two to polish it off... I did it properly and started moving syntax::ext::deriving off its tuple addiction onto some more structs.)

[huonw]

See #10355.

Unfortunately the only implementation that's possible right now means that the error doesn't mention the deriving at all, i.e. it just points at the field. I think that is the appropriate trade-off, but others may disagree...