Parse and typecheck moving out of enums (#2329)

Author: bblum

src/libsyntax/ast.rs

@@ -161,6 +161,7 @@ type field_pat = {ident: ident, pat: @pat};
 #[auto_serialize]
 enum binding_mode {
     bind_by_value,
+    bind_by_move,
     bind_by_ref(ast::mutability),
     bind_by_implicit_ref
 }

src/libsyntax/parse/parser.rs

@@ -16,7 +16,7 @@ import common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed,
 import dvec::dvec;
 import vec::{push};
 import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
-             bind_by_ref, bind_by_implicit_ref, bind_by_value,
+             bind_by_ref, bind_by_implicit_ref, bind_by_value, bind_by_move,
              bitand, bitor, bitxor, blk, blk_check_mode, bound_const,
              bound_copy, bound_send, bound_trait, bound_owned, box, by_copy,
              by_move, by_mutbl_ref, by_ref, by_val, capture_clause,
@@ -1887,12 +1887,17 @@ struct parser {
                 pat = self.parse_pat_ident(refutable, bind_by_ref(mutbl));
             } else if self.eat_keyword(~"copy") {
                 pat = self.parse_pat_ident(refutable, bind_by_value);
+            } else if self.eat_keyword(~"move") {
+                pat = self.parse_pat_ident(refutable, bind_by_move);
             } else if !is_plain_ident(self.token) {
                 pat = self.parse_enum_variant(refutable);
             } else {
                 let binding_mode;
+                // XXX: Aren't these two cases deadcode? -- bblum
                 if self.eat_keyword(~"copy") {
                     binding_mode = bind_by_value;
+                } else if self.eat_keyword(~"move") {
+                    binding_mode = bind_by_move;
                 } else if refutable {
                     // XXX: Should be bind_by_value, but that's not
                     // backward compatible.

src/libsyntax/print/pprust.rs

@@ -1442,6 +1442,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
             print_mutability(s, mutbl);
           }
           ast::bind_by_implicit_ref |
+          ast::bind_by_move | // this is totally the wrong thing
           ast::bind_by_value => {}
         }
         print_path(s, path, true);

src/rustc/middle/borrowck/gather_loans.rs

@@ -412,9 +412,10 @@ impl gather_loan_ctxt {
             match pat.node {
               ast::pat_ident(bm, id, o_pat) if !self.pat_is_variant(pat) => {
                 match bm {
-                  ast::bind_by_value => {
+                  ast::bind_by_value | ast::bind_by_move => {
                     // copying does not borrow anything, so no check
                     // is required
+                    // as for move, check::alt ensures it's from an rvalue.
                   }
                   ast::bind_by_ref(mutbl) => {
                     // ref x or ref x @ p --- creates a ptr which must

src/rustc/middle/lint.rs

@@ -490,7 +490,7 @@ fn check_pat(tcx: ty::ctxt, pat: @ast::pat) {
 
     do pat_bindings(tcx.def_map, pat) |binding_mode, id, span, path| {
         match binding_mode {
-          ast::bind_by_ref(_) | ast::bind_by_value => {}
+          ast::bind_by_ref(_) | ast::bind_by_value | ast::bind_by_move => {}
           ast::bind_by_implicit_ref => {
             let pat_ty = ty::node_id_to_type(tcx, id);
             let kind = ty::type_kind(tcx, pat_ty);

src/rustc/middle/mem_categorization.rs

@@ -409,6 +409,7 @@ impl &mem_categorization_ctxt {
           }
 
           ast::def_binding(vid, ast::bind_by_value) |
+          ast::def_binding(vid, ast::bind_by_move)  |
           ast::def_binding(vid, ast::bind_by_ref(_)) => {
             // by-value/by-ref bindings are local variables
             @{id:id, span:span,

src/rustc/middle/trans/alt.rs

@@ -474,6 +474,8 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
                                    load_if_immediate(bcx, llval, ty), ty);
                     bcx.fcx.lllocals.insert(val, local_mem(alloc));
                     add_clean(bcx, alloc, ty);
+                } else if mode == ast::bind_by_move {
+                    fail ~"can't translate bind_by_move into a pattern guard";
                 } else {
                     bcx.fcx.lllocals.insert(val, local_mem(llval));
                 }
@@ -803,6 +805,9 @@ fn make_pattern_bindings(bcx: block, phi_bindings: phi_bindings_list)
                                         local_mem(allocation));
                 add_clean(bcx, allocation, ty);
             }
+            ast::bind_by_move => {
+                fail ~"unimplemented -- bblum";
+            }
         }
     }
 

src/rustc/middle/typeck/check.rs

@@ -2035,7 +2035,10 @@ fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool {
         map: pat_id_map(fcx.ccx.tcx.def_map, local.node.pat),
         alt_region: region,
         block_region: region,
-        pat_region: region
+        pat_region: region,
+        matching_lvalue: true, // FIXME(#3235) Make this more flexible
+        has_guard: false,
+        mut ever_bound_by_ref: false,
     };
     alt::check_pat(pcx, local.node.pat, t);
     return bot;

src/rustc/middle/typeck/check/alt.rs

@@ -9,6 +9,7 @@ fn check_alt(fcx: @fn_ctxt,
 
     let pattern_ty = fcx.infcx.next_ty_var();
     bot = check_expr_with(fcx, discrim, pattern_ty);
+    let is_lvalue = ty::expr_is_lval(fcx.ccx.method_map, discrim);
 
     // Typecheck the patterns first, so that we get types for all the
     // bindings.
@@ -18,7 +19,12 @@ fn check_alt(fcx: @fn_ctxt,
             map: pat_id_map(tcx.def_map, arm.pats[0]),
             alt_region: ty::re_scope(expr.id),
             block_region: ty::re_scope(arm.body.node.id),
-            pat_region: ty::re_scope(expr.id)
+            pat_region: ty::re_scope(expr.id),
+            // The following three fields determine whether 'move' is allowed.
+            matching_lvalue: is_lvalue,
+            has_guard: arm.guard.is_some(),
+            // Each arm is freshly allowed to decide whether it can 'move'.
+            mut ever_bound_by_ref: false,
         };
 
         for arm.pats.each |p| { check_pat(pcx, p, pattern_ty);}
@@ -47,7 +53,14 @@ type pat_ctxt = {
     alt_region: ty::region,
     block_region: ty::region,
     /* Equal to either alt_region or block_region. */
-    pat_region: ty::region
+    pat_region: ty::region,
+    /* Moving out is only permitted when matching rvalues. */
+    matching_lvalue: bool,
+    /* Moving out is not permitted with guards. */
+    has_guard: bool,
+    /* If a pattern binding binds by-reference ever, then binding by-move in
+     * the same arm is disallowed (no "ref x @ some(move y)", etc etc). */
+    mut ever_bound_by_ref: bool,
 };
 
 fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
@@ -161,6 +174,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
 
         match bm {
           ast::bind_by_ref(mutbl) => {
+            pcx.ever_bound_by_ref = true;
             // if the binding is like
             //    ref x | ref const x | ref mut x
             // then the type of x is &M T where M is the mutability
@@ -172,8 +186,32 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
             let region_ty = ty::mk_rptr(tcx, region_var, mt);
             demand::eqtype(fcx, pat.span, region_ty, typ);
           }
-          ast::bind_by_value | ast::bind_by_implicit_ref => {
-            // otherwise the type of x is the expected type T
+          // otherwise the type of x is the expected type T
+          ast::bind_by_value => {
+            demand::eqtype(fcx, pat.span, expected, typ);
+          }
+          ast::bind_by_move => {
+            demand::eqtype(fcx, pat.span, expected, typ);
+            // check legality of moving out of the enum
+            if sub.is_some() {
+                tcx.sess.span_err(pat.span,
+                    ~"cannot bind by-move with sub-bindings");
+            }
+            if pcx.has_guard {
+                tcx.sess.span_err(pat.span,
+                    ~"cannot bind by-move into a pattern guard");
+            }
+            if pcx.ever_bound_by_ref {
+                tcx.sess.span_err(pat.span,
+                    ~"cannot bind by-move and by-ref in the same pattern");
+            }
+            if pcx.matching_lvalue {
+                tcx.sess.span_err(pat.span,
+                    ~"cannot bind by-move when matching an lvalue");
+            }
+          }
+          ast::bind_by_implicit_ref => {
+            pcx.ever_bound_by_ref = true;
             demand::eqtype(fcx, pat.span, expected, typ);
           }
         }