Distinguish move semantics for a @ Var(_) from that of Var(_).

Note that due to PR rust-lang#16053, we only actually deal with `a @ Var(_)`
here, (as opposed to a hypothetical `a @ Var(ref b)`, which cannot
currenty arise, and maybe will never be supported for non-copy data).

Author: pnkfelix

src/librustc/middle/expr_use_visitor.rs

@@ -1000,6 +1000,37 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
                         debug!("walk_pat binding consuming pat");
                         delegate.consume_pat(pat, cmt_pat, mode);
                     }
+
+                    ast::PatWild(_) => {
+                        match match_mode {
+                            NonBindingMatch |
+                            BorrowingMatch |
+                            CopyingMatch  => {}
+
+                            MovingMatch => {
+                                // On `enum E { Variant(Box<T>) }`, both of
+                                // the match arms:
+                                //
+                                //    Variant(a) => ...
+                                //    Variant(_) => ...
+                                //
+                                // are conceptually moving into the `Variant`
+                                // pattern, while the match arm:
+                                //
+                                //    a @ Variant(_) => ...
+                                //
+                                // is *not* moving into the `Variant(_)`.
+                                // Thus check the `pat_already_bound` flag to
+                                // distinguish the latter two cases.
+
+                                if !mc.pat_is_already_bound_by_value {
+                                    let mode = copy_or_move(typer.tcx(), cmt_pat.ty, PatBindingMove);
+                                    delegate.consume_pat(pat, cmt_pat, mode);
+                                }
+                            }
+                        }
+                    }
+
                     _ => {
                         typer.tcx().sess.span_bug(
                             pat.span,

src/librustc/middle/mem_categorization.rs

@@ -240,7 +240,11 @@ impl ast_node for ast::Pat {
 }
 
 pub struct MemCategorizationContext<'t,TYPER:'t> {
-    typer: &'t TYPER
+    typer: &'t TYPER,
+
+    // tracks when looking at `pat` in context of `id @ (... pat ...)`
+    // (it affects whether we move into a wildcard or not).
+    pub pat_is_already_bound_by_value: bool,
 }
 
 pub type McResult<T> = Result<T, ()>;
@@ -378,7 +382,20 @@ macro_rules! if_ok(
 
 impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
     pub fn new(typer: &'t TYPER) -> MemCategorizationContext<'t,TYPER> {
-        MemCategorizationContext { typer: typer }
+        MemCategorizationContext {
+            typer: typer,
+            pat_is_already_bound_by_value: false,
+        }
+    }
+
+    fn already_bound(&self, mode: ast::BindingMode) -> MemCategorizationContext<'t,TYPER> {
+        match mode {
+            ast::BindByRef(_) => *self,
+            ast::BindByValue(_) => MemCategorizationContext {
+                pat_is_already_bound_by_value: true,
+                ..*self
+            }
+        }
     }
 
     fn tcx(&self) -> &'t ty::ctxt<'tcx> {
@@ -1126,8 +1143,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             }
           }
 
-          ast::PatIdent(_, _, Some(ref subpat)) => {
-              if_ok!(self.cat_pattern(cmt, &**subpat, op));
+          ast::PatIdent(binding_mode, _, Some(ref subpat)) => {
+              if_ok!(self.already_bound(binding_mode).cat_pattern(cmt, &**subpat, op));
           }
 
           ast::PatIdent(_, _, None) => {
@@ -1136,9 +1153,21 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
 
           ast::PatStruct(_, ref field_pats, _) => {
             // {f1: p1, ..., fN: pN}
+            let downcast_cmt = match self.tcx().def_map.borrow().find(&pat.id) {
+                Some(&def::DefVariant(enum_did, variant_did, _)) => {
+                    // variant{ a: x, b: y, c: z }
+                    if ty::enum_is_univariant(self.tcx(), enum_did) {
+                        cmt // univariant, no downcast needed
+                    } else {
+                        self.cat_downcast(pat, cmt.clone(), cmt.ty, variant_did)
+                    }
+                }
+                _ => cmt,
+            };
+
             for fp in field_pats.iter() {
                 let field_ty = if_ok!(self.pat_ty(&*fp.pat)); // see (*2)
-                let cmt_field = self.cat_field(pat, cmt.clone(), fp.ident, field_ty);
+                let cmt_field = self.cat_field(pat, downcast_cmt.clone(), fp.ident, field_ty);
                 if_ok!(self.cat_pattern(cmt_field, &*fp.pat, |x,y,z| op(x,y,z)));
             }
           }
@@ -1377,8 +1406,8 @@ impl Repr for categorization {
             cat_interior(ref cmt, interior) => {
                 format!("{}.{}", cmt.cat.repr(tcx), interior.repr(tcx))
             }
-            cat_downcast(ref cmt, _) => {
-                format!("{}->(enum)", cmt.cat.repr(tcx))
+            cat_downcast(ref cmt, ref variant_did) => {
+                format!("({}->{})", cmt.cat.repr(tcx), variant_did.repr(tcx))
             }
             cat_discr(ref cmt, _) => {
                 cmt.cat.repr(tcx)