Remove the capture mode map and just store the capture mode for individual variables.

Also add test. Fixes #16749.

src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs

@@ -58,8 +58,10 @@ fn test6() {
 fn test7() {
     fn foo<F>(_: F) where F: FnMut(Box<FnMut(isize)>, isize) {}
     let mut f = |&mut: g: Box<FnMut(isize)>, b: isize| {};
-    f(box |a| { //~ ERROR: cannot borrow `f` as immutable because it is also borrowed as mutable
-        foo(f); //~ ERROR: cannot move out of captured outer variable
+    f(box |a| {
+        foo(f);
+        //~^ ERROR cannot move `f` into closure because it is borrowed
+        //~| ERROR cannot move out of captured outer variable in an `FnMut` closure
     }, 3);
 }
 

src/test/compile-fail/unboxed-closure-illegal-move.rs

@@ -19,24 +19,24 @@ fn main() {
     // By-ref cases
     {
         let x = box 0us;
-        let f = |&:| drop(x); //~ cannot move
+        let f = |&:| drop(x); //~ ERROR cannot move
     }
     {
         let x = box 0us;
-        let f = |&mut:| drop(x); //~ cannot move
+        let f = |&mut:| drop(x); //~ ERROR cannot move
     }
     {
         let x = box 0us;
-        let f = |:| drop(x); //~ cannot move
+        let f = |:| drop(x); // OK -- FnOnce
     }
     // By-value cases
     {
         let x = box 0us;
-        let f = move |&:| drop(x); //~ cannot move
+        let f = move |&:| drop(x); //~ ERROR cannot move
     }
     {
         let x = box 0us;
-        let f = move |&mut:| drop(x); //~ cannot move
+        let f = move |&mut:| drop(x); //~ ERROR cannot move
     }
     {
         let x = box 0us;

src/test/compile-fail/unboxed-closures-mutate-upvar.rs

@@ -0,0 +1,62 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that we cannot mutate an outer variable that is not declared
+// as `mut` through a closure. Also test that we CAN mutate a moved copy,
+// unless this is a `Fn` closure. Issue #16749.
+
+use std::mem;
+
+fn a() {
+    let n = 0u8;
+    let mut f = |&mut:| { //~ ERROR closure cannot assign
+        n += 1;
+    };
+}
+
+fn b() {
+    let mut n = 0u8;
+    let mut f = |&mut:| {
+        n += 1; // OK
+    };
+}
+
+fn c() {
+    let n = 0u8;
+    let mut f = move |&mut:| {
+        // If we just did a straight-forward desugaring, this would
+        // compile, but we do something a bit more subtle, and hence
+        // we get an error.
+        n += 1; //~ ERROR cannot assign
+    };
+}
+
+fn d() {
+    let mut n = 0u8;
+    let mut f = move |&mut:| {
+        n += 1; // OK
+    };
+}
+
+fn e() {
+    let n = 0u8;
+    let mut f = move |&:| {
+        n += 1; //~ ERROR cannot assign
+    };
+}
+
+fn f() {
+    let mut n = 0u8;
+    let mut f = move |&:| {
+        n += 1; //~ ERROR cannot assign
+    };
+}
+
+fn main() { }