Lifetime handling doesn't handle function pointers properly

[LeoTestard]

Let's say I've got a struct or enum containing functions (pure Rust functions, not closures, so passed by a simple pointer)

pub type Foo = fn(&int) -> ();

enum Baz {
    Bar(Foo)
}

The above code works. I can pass-around instances of Baz and call the function.
Now if I wan Baz to be copy-able, which should be possible since it only contains a pointer, and add the #[deriving(Clone)] attribute to it, I got a strange compiler error:

error: mismatched types: expected `fn(&int)` but found `fn(&int)` (expected concrete lifetime, but found bound lifetime parameter &)
test.rs:4 #[deriving(Clone)]

This worked perfectly well (including the deriving(Clone) attribute) while the function only took parameters by owned boxes or by-value. I only get this message since I added a borrowed parameter to the function. I don't see the problem here. If a function is simply passed by-pointer we should be able to copy this pointer.

I'm not sure this is the right title for this issue. Feel free to change it if it's miss chosen.

[huonw]

cc @nikomatsakis, possibly related to #10153?

[nikomatsakis]

Interesting. Not related to #10153 I don't think but probably to the fix for #4846 -- this has something to do with the code that computes GLB/LUB of fn types, I imagine.

[nikomatsakis]

Sorry, #10153 IS the fix for #4846. Anyway, yes, thanks @huonw

[nikomatsakis]

Hmm. The error message is...horribly cryptic but the error seems legit. (Probably worth thinking, independently, on SOMETHING better to print out there, but I'm not sure what).

I was wrong, not related to #10153. This is kind of a flaw in the way that the "clone" operation is defined over fn types, but I'm not actually sure how it can be fixed without modifying the compiler to introduce some special bounds.

Let me elaborate a bit on the problem, as much for myself as anyone else (it's somewhat subtle). The definition of clone for fn pointers is roughly like:

impl<A,R> Clone for fn(A) -> R {
    fn clone(&self) -> fn(A) -> R { *self }
}

What happens here is that the type in question is (written out fully explicitly) <'a> fn(&'a int) -> (). In other words, it's a function that takes a borrowed int with any lifetime 'a, and that lifetime can be specified at call time. The problem is that the clone impl cannot express the notion of "a borrowed pointer with any lifetime". The type variable A here must be bound to a borrowed pointer with some specific lifetime. So the call to "f.clone()" winds up producing a fn with a type like fn(&'b int) -> () -- in other words, a function that takes a borrowed pointer with some lifetime 'b. This new type is not as general as the old one, though, because it only accepts a single lifetime, not any lifetime, and hence you wind up with a type error.

This is hard to fix. I'm not 100% sure what the "right" fix would even be, actually. But one possible fix is to add a builtin bound to the compiler, let's call it Simple, for want of a better name. I envision that Simple matches "simple" types. To avoid this bug, Simple must include fn pointers. It could also include integers, borrowed pointers, and *T pointers -- basically things that are "builtin types that are cloned just by copying their bits" but excluding compound types like structs and tuples. Otherwise this def'n is very close to implicitly copyable and sort of close to POD.

Given this bound, we might have an impl for clone like:

impl<T:Simple> Clone for T {
    fn clone(&self) -> T { *self } // compiler knows this is a copy, not move, due to Simple bound
}

this avoids the problem by not binding type parameters to the individual argument types. It's also more general.

[nikomatsakis]

This was never fixed, but the code got buggy.