---

yaml
---
r: 152600
b: refs/heads/try2
c: 7b42e38
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: acc944a35c315c97e9c666cee7f55f7a795ecf04
+refs/heads/try2: 7b42e3851c320d5a5f0f27c2b5649efafd8e5057
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -3247,7 +3247,7 @@ fn main() { println!("hello {}", world::explore()); }
 Now compile and run like this (adjust to your platform if necessary):
 
 ~~~~console
-$ rustc --crate-type=lib world.rs  # compiles libworld-<HASH>-0.42.rlib
+$ rustc --crate-type=lib world.rs  # compiles libworld-<HASH>-0.42.so
 $ rustc main.rs -L .               # compiles main
 $ ./main
 "hello world"

branches/try2/src/etc/emacs/rust-mode.el

@@ -212,9 +212,9 @@
      ;; Special types
      (,(regexp-opt rust-special-types 'words) . font-lock-type-face)
 
-     ;; Attributes like `#[bar(baz)]` or `#![bar(baz)]` or `#[bar = "baz"]`
-     (,(rust-re-grab (concat "#\\!?\\[" rust-re-ident "[^]]*\\]"))
-      1 font-lock-preprocessor-face t)
+     ;; Attributes like `#[bar(baz)]` or `#![bar(baz)]`
+     (,(rust-re-grab (concat "#\\!?[" rust-re-ident "[^]]*\\]"))
+      1 font-lock-preprocessor-face)
 
      ;; Syntax extension invocations like `foo!`, highlight including the !
      (,(concat (rust-re-grab (concat rust-re-ident "!")) "[({[:space:][]")

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -155,12 +155,6 @@ enum UseError {
     UseWhileBorrowed(/*loan*/Rc<LoanPath>, /*loan*/Span)
 }
 
-fn compatible_borrow_kinds(borrow_kind1: ty::BorrowKind,
-                           borrow_kind2: ty::BorrowKind)
-                           -> bool {
-    borrow_kind1 == ty::ImmBorrow && borrow_kind2 == ty::ImmBorrow
-}
-
 impl<'a> CheckLoanCtxt<'a> {
     pub fn tcx(&self) -> &'a ty::ctxt { self.bccx.tcx }
 
@@ -195,75 +189,29 @@ impl<'a> CheckLoanCtxt<'a> {
         })
     }
 
-    fn each_in_scope_loan_affecting_path(&self,
-                                         scope_id: ast::NodeId,
-                                         loan_path: &LoanPath,
-                                         op: |&Loan| -> bool)
-                                         -> bool {
-        //! Iterates through all of the in-scope loans affecting `loan_path`,
-        //! calling `op`, and ceasing iteration if `false` is returned.
+    pub fn each_in_scope_restriction(&self,
+                                     scope_id: ast::NodeId,
+                                     loan_path: &LoanPath,
+                                     op: |&Loan, &Restriction| -> bool)
+                                     -> bool {
+        //! Iterates through all the in-scope restrictions for the
+        //! given `loan_path`
 
-        // First, we check for a loan restricting the path P being used. This
-        // accounts for borrows of P but also borrows of subpaths, like P.a.b.
-        // Consider the following example:
-        //
-        //     let x = &mut a.b.c; // Restricts a, a.b, and a.b.c
-        //     let y = a;          // Conflicts with restriction
+        self.each_in_scope_loan(scope_id, |loan| {
+            debug!("each_in_scope_restriction found loan: {:?}",
+                   loan.repr(self.tcx()));
 
-        let cont = self.each_in_scope_loan(scope_id, |loan| {
             let mut ret = true;
-            for restr_path in loan.restricted_paths.iter() {
-                if **restr_path == *loan_path {
-                    if !op(loan) {
+            for restr in loan.restrictions.iter() {
+                if *restr.loan_path == *loan_path {
+                    if !op(loan, restr) {
                         ret = false;
                         break;
                     }
                 }
             }
             ret
-        });
-
-        if !cont {
-            return false;
-        }
-
-        // Next, we must check for *loans* (not restrictions) on the path P or
-        // any base path. This rejects examples like the following:
-        //
-        //     let x = &mut a.b;
-        //     let y = a.b.c;
-        //
-        // Limiting this search to *loans* and not *restrictions* means that
-        // examples like the following continue to work:
-        //
-        //     let x = &mut a.b;
-        //     let y = a.c;
-
-        let mut loan_path = loan_path;
-        loop {
-            match *loan_path {
-                LpVar(_) => {
-                    break;
-                }
-                LpExtend(ref lp_base, _, _) => {
-                    loan_path = &**lp_base;
-                }
-            }
-
-            let cont = self.each_in_scope_loan(scope_id, |loan| {
-                if *loan.loan_path == *loan_path {
-                    op(loan)
-                } else {
-                    true
-                }
-            });
-
-            if !cont {
-                return false;
-            }
-        }
-
-        return true;
+        })
     }
 
     pub fn loans_generated_by(&self, scope_id: ast::NodeId) -> Vec<uint> {
@@ -340,12 +288,26 @@ impl<'a> CheckLoanCtxt<'a> {
                loan1.repr(self.tcx()),
                loan2.repr(self.tcx()));
 
-        if compatible_borrow_kinds(loan1.kind, loan2.kind) {
-            return true;
-        }
+        // Restrictions that would cause the new loan to be illegal:
+        let illegal_if = match loan2.kind {
+            // Look for restrictions against mutation. These are
+            // generated by all other borrows.
+            ty::MutBorrow => RESTR_MUTATE,
+
+            // Look for restrictions against freezing (immutable borrows).
+            // These are generated by `&mut` borrows.
+            ty::ImmBorrow => RESTR_FREEZE,
 
-        for restr_path in loan1.restricted_paths.iter() {
-            if *restr_path != loan2.loan_path { continue; }
+            // No matter how the data is borrowed (as `&`, as `&mut`,
+            // or as `&unique imm`) it will always generate a
+            // restriction against mutating the data. So look for those.
+            ty::UniqueImmBorrow => RESTR_MUTATE,
+        };
+        debug!("illegal_if={:?}", illegal_if);
+
+        for restr in loan1.restrictions.iter() {
+            if !restr.set.intersects(illegal_if) { continue; }
+            if restr.loan_path != loan2.loan_path { continue; }
 
             let old_pronoun = if new_loan.loan_path == old_loan.loan_path {
                 "it".to_string()
@@ -572,16 +534,63 @@ impl<'a> CheckLoanCtxt<'a> {
 
         let mut ret = UseOk;
 
-        self.each_in_scope_loan_affecting_path(expr_id, use_path, |loan| {
-            if !compatible_borrow_kinds(loan.kind, borrow_kind) {
+        // First, we check for a restriction on the path P being used. This
+        // accounts for borrows of P but also borrows of subpaths, like P.a.b.
+        // Consider the following example:
+        //
+        //     let x = &mut a.b.c; // Restricts a, a.b, and a.b.c
+        //     let y = a;          // Conflicts with restriction
+
+        self.each_in_scope_restriction(expr_id, use_path, |loan, _restr| {
+            if incompatible(loan.kind, borrow_kind) {
                 ret = UseWhileBorrowed(loan.loan_path.clone(), loan.span);
                 false
             } else {
                 true
             }
         });
 
+        // Next, we must check for *loans* (not restrictions) on the path P or
+        // any base path. This rejects examples like the following:
+        //
+        //     let x = &mut a.b;
+        //     let y = a.b.c;
+        //
+        // Limiting this search to *loans* and not *restrictions* means that
+        // examples like the following continue to work:
+        //
+        //     let x = &mut a.b;
+        //     let y = a.c;
+
+        let mut loan_path = use_path;
+        loop {
+            self.each_in_scope_loan(expr_id, |loan| {
+                if *loan.loan_path == *loan_path &&
+                   incompatible(loan.kind, borrow_kind) {
+                    ret = UseWhileBorrowed(loan.loan_path.clone(), loan.span);
+                    false
+                } else {
+                    true
+                }
+            });
+
+            match *loan_path {
+                LpVar(_) => {
+                    break;
+                }
+                LpExtend(ref lp_base, _, _) => {
+                    loan_path = &**lp_base;
+                }
+            }
+        }
+
         return ret;
+
+        fn incompatible(borrow_kind1: ty::BorrowKind,
+                        borrow_kind2: ty::BorrowKind)
+                        -> bool {
+            borrow_kind1 != ty::ImmBorrow || borrow_kind2 != ty::ImmBorrow
+        }
     }
 
     fn check_if_path_is_moved(&self,
@@ -659,9 +668,11 @@ impl<'a> CheckLoanCtxt<'a> {
         // and aliasing restrictions:
         if assignee_cmt.mutbl.is_mutable() {
             if check_for_aliasable_mutable_writes(self, assignment_span, assignee_cmt.clone()) {
-                if mode != euv::Init {
-                    check_for_assignment_to_borrowed_path(
-                        self, assignment_id, assignment_span, assignee_cmt.clone());
+                if mode != euv::Init &&
+                    check_for_assignment_to_restricted_or_frozen_location(
+                        self, assignment_id, assignment_span, assignee_cmt.clone())
+                {
+                    // Safe, but record for lint pass later:
                     mark_variable_as_used_mut(self, assignee_cmt);
                 }
             }
@@ -796,24 +807,138 @@ impl<'a> CheckLoanCtxt<'a> {
             }
         }
 
-        fn check_for_assignment_to_borrowed_path(
+        fn check_for_assignment_to_restricted_or_frozen_location(
             this: &CheckLoanCtxt,
             assignment_id: ast::NodeId,
             assignment_span: Span,
-            assignee_cmt: mc::cmt)
+            assignee_cmt: mc::cmt) -> bool
         {
             //! Check for assignments that violate the terms of an
             //! outstanding loan.
 
             let loan_path = match opt_loan_path(&assignee_cmt) {
                 Some(lp) => lp,
-                None => { return; /* no loan path, can't be any loans */ }
+                None => { return true; /* no loan path, can't be any loans */ }
             };
 
-            this.each_in_scope_loan_affecting_path(assignment_id, &*loan_path, |loan| {
-                this.report_illegal_mutation(assignment_span, &*loan_path, loan);
-                false
+            // Start by searching for an assignment to a *restricted*
+            // location. Here is one example of the kind of error caught
+            // by this check:
+            //
+            //    let mut v = ~[1, 2, 3];
+            //    let p = &v;
+            //    v = ~[4];
+            //
+            // In this case, creating `p` triggers a RESTR_MUTATE
+            // restriction on the path `v`.
+            //
+            // Here is a second, more subtle example:
+            //
+            //    let mut v = ~[1, 2, 3];
+            //    let p = &const v[0];
+            //    v[0] = 4;                   // OK
+            //    v[1] = 5;                   // OK
+            //    v = ~[4, 5, 3];             // Error
+            //
+            // In this case, `p` is pointing to `v[0]`, and it is a
+            // `const` pointer in any case. So the first two
+            // assignments are legal (and would be permitted by this
+            // check). However, the final assignment (which is
+            // logically equivalent) is forbidden, because it would
+            // cause the existing `v` array to be freed, thus
+            // invalidating `p`. In the code, this error results
+            // because `gather_loans::restrictions` adds a
+            // `RESTR_MUTATE` restriction whenever the contents of an
+            // owned pointer are borrowed, and hence while `v[*]` is not
+            // restricted from being written, `v` is.
+            let cont = this.each_in_scope_restriction(assignment_id,
+                                                      &*loan_path,
+                                                      |loan, restr| {
+                if restr.set.intersects(RESTR_MUTATE) {
+                    this.report_illegal_mutation(assignment_span, &*loan_path, loan);
+                    false
+                } else {
+                    true
+                }
             });
+
+            if !cont { return false }
+
+            // The previous code handled assignments to paths that
+            // have been restricted. This covers paths that have been
+            // directly lent out and their base paths, but does not
+            // cover random extensions of those paths. For example,
+            // the following program is not declared illegal by the
+            // previous check:
+            //
+            //    let mut v = ~[1, 2, 3];
+            //    let p = &v;
+            //    v[0] = 4; // declared error by loop below, not code above
+            //
+            // The reason that this passes the previous check whereas
+            // an assignment like `v = ~[4]` fails is because the assignment
+            // here is to `v[*]`, and the existing restrictions were issued
+            // for `v`, not `v[*]`.
+            //
+            // So in this loop, we walk back up the loan path so long
+            // as the mutability of the path is dependent on a super
+            // path, and check that the super path was not lent out as
+            // mutable or immutable (a const loan is ok).
+            //
+            // Mutability of a path can be dependent on the super path
+            // in two ways. First, it might be inherited mutability.
+            // Second, the pointee of an `&mut` pointer can only be
+            // mutated if it is found in an unaliased location, so we
+            // have to check that the owner location is not borrowed.
+            //
+            // Note that we are *not* checking for any and all
+            // restrictions.  We are only interested in the pointers
+            // that the user created, whereas we add restrictions for
+            // all kinds of paths that are not directly aliased. If we checked
+            // for all restrictions, and not just loans, then the following
+            // valid program would be considered illegal:
+            //
+            //    let mut v = ~[1, 2, 3];
+            //    let p = &const v[0];
+            //    v[1] = 5; // ok
+            //
+            // Here the restriction that `v` not be mutated would be misapplied
+            // to block the subpath `v[1]`.
+            let full_loan_path = loan_path.clone();
+            let mut loan_path = loan_path;
+            loop {
+                loan_path = match *loan_path {
+                    // Peel back one layer if, for `loan_path` to be
+                    // mutable, `lp_base` must be mutable. This occurs
+                    // with inherited mutability, owned pointers and
+                    // `&mut` pointers.
+                    LpExtend(ref lp_base, mc::McInherited, _) |
+                    LpExtend(ref lp_base, _, LpDeref(mc::OwnedPtr)) |
+                    LpExtend(ref lp_base, _, LpDeref(mc::GcPtr)) |
+                    LpExtend(ref lp_base, _, LpDeref(mc::BorrowedPtr(ty::MutBorrow, _))) => {
+                        lp_base.clone()
+                    }
+
+                    // Otherwise stop iterating
+                    LpExtend(_, mc::McDeclared, _) |
+                    LpExtend(_, mc::McImmutable, _) |
+                    LpVar(_) => {
+                        return true;
+                    }
+                };
+
+                // Check for a non-const loan of `loan_path`
+                let cont = this.each_in_scope_loan(assignment_id, |loan| {
+                    if loan.loan_path == loan_path {
+                        this.report_illegal_mutation(assignment_span, &*full_loan_path, loan);
+                        false
+                    } else {
+                        true
+                    }
+                });
+
+                if !cont { return false }
+            }
         }
     }