Finalize unboxed closure feature gates for 1.0

[nikomatsakis]

We do not expect to completely "unfeature-gate" unboxed closures for 1.0. We wish to reserve the flexibility to change a few aspects:

1. Move to variadic generics in place of auto-tupling.
2. Change the A and R arguments from input types to (possibly) associated types. (cc Make return type of the Fn traits an associated type #20871)
3. Improve the coherence story with respect to fn-trait hierarchy. (cc Unable to manually implement FnOnce #18835)

To this end we will adjust the features to:

• Disallow references to the Fn* traits using angle bracket notation
• Disallow user impls of the Fn* traits
• Disallow direct calls to foo.call()
• Disallow parenthetical notation (Foo(A,B) -> C) from being used with anything other than the Fn* traits

In short, we permit unboxed closures to be used as if they are a language builtin, but disallow (for now) a lot of the more generic uses. We should be able to drop this feature gate shortly after 1.0.

cc @pcwalton

[nikomatsakis]

Nominating for 1.0 or something. :)

[pnkfelix]

P-backcompat-lang, 1.0.

[nikomatsakis]

Note that some of this works today though it ought not, e.g. manually implementing Fn traits.

[bstrie]

To expand on @nikomatsakis' comment, the following code fails to compile due to the lack of a feature that should be gated:

struct MemberFn<'a, T, R, A0> where T : 'a {
    fun: fn (&T, A0) -> R,
    obj: &'a T
}

impl<'a, T, R, A0> MemberFn<'a, T, R, A0> where T : 'a {
    fn new(o: &'a T, f: fn (&T, A0) -> R) -> MemberFn<'a, T, R, A0> {
        MemberFn {
            fun: f,
            obj: o
        }
    }
}

impl<'a, T, R, A0, Args> Fn<Args, R> for MemberFn<'a, T, R, A0> where Args : Tuple1<A0> {
   fn call(&self, args: Args) -> R {
        (self.fun)(self.obj, args.val0())
    }
}

fn main() {
    println!("Hello, world!")
}

The current solution is to put extern "rust-call" on the call function.

[nikomatsakis]

This was done, or done enough.

[nikomatsakis]

Oops, I totally overlooked that Fn<(),()> is still considered legal. It's important to adjust that too!