Don't allow Fn unboxed closures to mutate upvars

[bkoropoff]

This fixes a soundness problem where Fn unboxed closures can mutate free variables in the environment.
The following presently builds:

#![feature(unboxed_closures, overloaded_calls)]

fn main() {
    let mut x = 0u;
    let _f = |&:| x = 42;
}

However, this is equivalent to writing the following, which borrowck rightly rejects:

struct F<'a> {
    x: &'a mut uint
}

impl<'a> Fn<(),()> for F<'a> {
    #[rust_call_abi_hack]
    fn call(&self, _: ()) {
        *self.x = 42; // error: cannot assign to data in a `&` reference
    }
}

fn main() {
    let mut x = 0u;
    let _f = F { x: &mut x };
}

This problem is unique to unboxed closures; boxed closures cannot be invoked through an immutable reference and are not subject to it.

This change marks upvars of Fn unboxed closures as freely aliasable in mem_categorization, which causes borrowck to reject attempts to mutate or mutably borrow them.

@zwarich pointed out that even with this change, there are remaining soundness issues related to regionck (issue #17403). This region issue affects boxed closures as well.

Closes issue #17780

[huonw]

r? @nikomatsakis

This change marks by-reference upvars of Fn unboxed closures as freely aliasable in mem_categorization, which causes borrowck to reject attempts to mutate or mutably borrow them.

Aren't by-value upvars also freely aliasable? E.g. you can have two concurrent calls to a given Fn closure by sharing it between threads in an Arc.

(I don't know if this is currently handled correctly or not.)

[bkoropoff]

Hmm, it looked like that case was handled already:

            cat_copied_upvar(CopiedUpvar {onceness: ast::Many, ..}) => {
                Some(AliasableOther)
            }

However, it doesn't seem to prevent mutation. I'll have to look into it.

[bkoropoff]

@huonw I have a fix for the by-value upvar case you mentioned. Should it get tacked on to this PR, or should I hold off and submit it separately after this one goes in?

[bkoropoff]

It was cleaner to rebase and squash the fixes together. I think this is good to go.