---

yaml
---
r: 13015
b: refs/heads/master
c: 30b4764
h: refs/heads/master
i:
  13013: 3210963
  13011: ccd14ea
  13007: fdf8e9d
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a3be0b105436118e187ea52deb89788afaf1edb5
+refs/heads/master: 30b47649ea37d211ee2dec4c541e6ba1e64c31a8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/librustsyntax/ast.rs

@@ -351,7 +351,7 @@ enum expr_ {
 }
 
 #[auto_serialize]
-type capture_item = {
+type capture_item = @{
     id: int,
     is_move: bool,
     name: ident, // Currently, can only capture a local var.

trunk/src/librustsyntax/parse/parser.rs

@@ -434,7 +434,7 @@ class parser {
         fn parse_capture_item(p:parser, is_move: bool) -> capture_item {
             let sp = mk_sp(p.span.lo, p.span.hi);
             let ident = parse_ident(p);
-            {id: p.get_id(), is_move: is_move, name: ident, span: sp}
+            @{id: p.get_id(), is_move: is_move, name: ident, span: sp}
         }
 
         if eat_keyword(self, "move") {
@@ -1710,7 +1710,7 @@ class parser {
                     let id = p.get_id();
                     let sp = mk_sp(p.span.lo, p.span.hi);
                     let ident = parse_ident(p);
-                    res += [{id:id, is_move: is_move, name:ident, span:sp}];
+                    res += [@{id:id, is_move: is_move, name:ident, span:sp}];
                     if !eat(p, token::COMMA) {
                         ret res;
                     }

trunk/src/rustc/driver/driver.rs

@@ -192,6 +192,9 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
          bind middle::check_loop::check_crate(ty_cx, crate));
     time(time_passes, "alt checking",
          bind middle::check_alt::check_crate(ty_cx, crate));
+    let _last_use_map =
+        time(time_passes, "liveness checking",
+             bind middle::liveness::check_crate(ty_cx, method_map, crate));
     time(time_passes, "typestate checking",
          bind middle::tstate::ck::check_crate(ty_cx, crate));
     let (root_map, mutbl_map) = time(

trunk/src/rustc/middle/borrowck.rs

@@ -541,6 +541,15 @@ enum assignment_type {
 }
 
 impl methods for assignment_type {
+    fn checked_by_liveness() -> bool {
+        // the liveness pass guarantees that immutable local variables
+        // are only assigned once; but it doesn't consider &mut
+        alt self {
+          at_straight_up {true}
+          at_swap {true}
+          at_mutbl_ref {false}
+        }
+    }
     fn ing_form(desc: str) -> str {
         alt self {
           at_straight_up { "assigning to " + desc }
@@ -717,6 +726,13 @@ impl methods for check_loan_ctxt {
         }
     }
 
+    fn is_local_variable(cmt: cmt) -> bool {
+        alt cmt.cat {
+          cat_local(_) {true}
+          _ {false}
+        }
+    }
+
     fn is_self_field(cmt: cmt) -> bool {
         alt cmt.cat {
           cat_comp(cmt_base, comp_field(_)) {
@@ -735,9 +751,13 @@ impl methods for check_loan_ctxt {
         #debug["check_assignment(cmt=%s)",
                self.bccx.cmt_to_repr(cmt)];
 
-        // check that the lvalue `ex` is assignable, but be careful
-        // because assigning to self.foo in a ctor is always allowed.
-        if !self.in_ctor || !self.is_self_field(cmt) {
+        if self.in_ctor && self.is_self_field(cmt)
+            && at.checked_by_liveness() {
+            // assigning to self.foo in a ctor is always allowed.
+        } else if self.is_local_variable(cmt) && at.checked_by_liveness() {
+            // liveness guarantees that immutable local variables
+            // are only assigned once
+        } else {
             alt cmt.mutbl {
               m_mutbl { /*ok*/ }
               m_const | m_imm {

trunk/src/rustc/middle/capture.rs

@@ -1,5 +1,6 @@
 import syntax::{ast, ast_util};
 import driver::session::session;
+import syntax::codemap::span;
 import std::map;
 import std::map::hashmap;
 
@@ -14,15 +15,17 @@ export cap_drop;
 export cap_ref;
 
 enum capture_mode {
-    cap_copy, //< Copy the value into the closure.
-    cap_move, //< Move the value into the closure.
-    cap_drop, //< Drop value after creating closure.
-    cap_ref,  //< Reference directly from parent stack frame (block fn).
+    cap_copy, // Copy the value into the closure.
+    cap_move, // Move the value into the closure.
+    cap_drop, // Drop value after creating closure.
+    cap_ref,  // Reference directly from parent stack frame (block fn).
 }
 
 type capture_var = {
-    def: ast::def,     //< The variable being accessed free.
-    mode: capture_mode //< How is the variable being accessed.
+    def: ast::def,                       // Variable being accessed free
+    span: span,                          // Location of access or cap item
+    cap_item: option<ast::capture_item>, // Capture item, if any
+    mode: capture_mode                   // How variable is being accessed
 };
 
 type capture_map = map::hashmap<ast::def_id, capture_var>;
@@ -70,15 +73,24 @@ fn compute_capture_vars(tcx: ty::ctxt,
             // if we are moving the value in, but it's not actually used,
             // must drop it.
             if vec::any(*freevars, {|fv| fv.def == cap_def}) {
-                cap_map.insert(cap_def_id, { def:cap_def, mode:cap_move });
+                cap_map.insert(cap_def_id, {def:cap_def,
+                                            span: cap_item.span,
+                                            cap_item: some(cap_item),
+                                            mode:cap_move});
             } else {
-                cap_map.insert(cap_def_id, { def:cap_def, mode:cap_drop });
+                cap_map.insert(cap_def_id, {def:cap_def,
+                                            span: cap_item.span,
+                                            cap_item: some(cap_item),
+                                            mode:cap_drop});
             }
         } else {
             // if we are copying the value in, but it's not actually used,
             // just ignore it.
             if vec::any(*freevars, {|fv| fv.def == cap_def}) {
-                cap_map.insert(cap_def_id, { def:cap_def, mode:cap_copy });
+                cap_map.insert(cap_def_id, {def:cap_def,
+                                            span: cap_item.span,
+                                            cap_item: some(cap_item),
+                                            mode:cap_copy});
             }
         }
     }
@@ -96,7 +108,10 @@ fn compute_capture_vars(tcx: ty::ctxt,
         alt cap_map.find(fvar_def_id) {
           option::some(_) { /* was explicitly named, do nothing */ }
           option::none {
-            cap_map.insert(fvar_def_id, {def:fvar.def, mode:implicit_mode});
+            cap_map.insert(fvar_def_id, {def:fvar.def,
+                                         span: fvar.span,
+                                         cap_item: none,
+                                         mode:implicit_mode});
           }
         }
     }