---

yaml
---
r: 15831
b: refs/heads/try
c: 63210ec
h: refs/heads/master
i:
  15829: 90d67b2
  15827: 1429139
  15823: 5deb217
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 5c8069d817d5be3dc577dce6ab59ebfd89d19843
+refs/heads/try: 63210ecddb74fb601a17314c6866685d74fa89dc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/middle/borrowck.rs

@@ -1481,17 +1481,17 @@ impl preserve_methods for preserve_ctxt {
             // Unsafe pointers are the user's problem
             ok(())
           }
-          cat_deref(_, derefs, gc_ptr) {
+          cat_deref(base, derefs, gc_ptr) {
             // GC'd pointers of type @MT: always stable because we can inc
             // the ref count or keep a GC root as necessary.  We need to
             // insert this id into the root_map, however.
             alt self.opt_scope_id {
               some(scope_id) {
                 #debug["Inserting root map entry for %s: \
                         node %d:%u -> scope %d",
-                       self.bccx.cmt_to_repr(cmt), cmt.id,
+                       self.bccx.cmt_to_repr(cmt), base.id,
                        derefs, scope_id];
-                let rk = {id: cmt.id, derefs: derefs};
+                let rk = {id: base.id, derefs: derefs};
                 self.bccx.root_map.insert(rk, scope_id);
                 ok(())
               }

branches/try/src/test/compile-fail/regions-appearance-constraint.rs

@@ -0,0 +1,35 @@
+/*
+
+Tests that borrowing always produces a pointer confined to the
+innermost scope.  In this case, the variable `a` gets inferred
+to the lifetime of the `if` statement because it is assigned
+a borrow of `y` which takes place within the `if`.
+
+Note: If this constraint were lifted (as I contemplated at one point),
+it complicates the preservation mechanics in trans, though not
+irreperably.  I'm partially including this test so that if these
+semantics do change we'll remember to test this scenario.
+
+*/
+
+fn testfn(cond: bool) {
+    let mut x = @3;
+    let mut y = @4;
+
+    let mut a = &*x;
+    //!^ ERROR reference is not valid outside of its lifetime
+
+    let mut exp = 3;
+    if cond {
+        a = &*y;
+
+        exp = 4;
+    }
+
+    x = @5;
+    y = @6;
+    assert *a == exp;
+}
+
+fn main() {
+}

branches/try/src/test/run-pass/borrowck-preserve-cond-box.rs

@@ -0,0 +1,31 @@
+// compile-flags:--borrowck=err
+// exec-env:RUST_POISON_ON_FREE=1
+
+fn testfn(cond: bool) {
+    let mut x = @3;
+    let mut y = @4;
+
+    // borrow x and y
+    let mut r_x = &*x;
+    let mut r_y = &*y;
+    let mut r = r_x, exp = 3;
+
+    if cond {
+        r = r_y;
+        exp = 4;
+    }
+
+    #debug["*r = %d, exp = %d", *r, exp];
+    assert *r == exp;
+
+    x = @5;
+    y = @6;
+
+    #debug["*r = %d, exp = %d", *r, exp];
+    assert *r == exp;
+}
+
+fn main() {
+    testfn(true);
+    testfn(false);
+}