---

yaml
---
r: 60055
b: refs/heads/master
c: 6af447a
h: refs/heads/master
i:
  60053: b8b37aa
  60051: 642e52c
  60047: 868bb47
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 11f7cb26c27c3eb3af3f7ef4f9cdb85327e6e030
+refs/heads/master: 6af447a271a52d0eb4b5e8e3d66e7aede967ac52
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/librustc/middle/trans/datum.rs

@@ -548,9 +548,11 @@ pub impl Datum {
     }
 
     fn to_rptr(&self, bcx: block) -> Datum {
-        //! Returns a new datum of region-pointer type containing the
-        //! the same ptr as this datum (after converting to by-ref
-        //! using `to_ref_llval()`).
+        //!
+        //
+        // Returns a new datum of region-pointer type containing the
+        // the same ptr as this datum (after converting to by-ref
+        // using `to_ref_llval()`).
 
         // Convert to ref, yielding lltype *T.  Then create a Rust
         // type &'static T (which translates to *T).  Construct new

trunk/src/librustc/middle/trans/expr.rs

@@ -183,25 +183,30 @@ fn drop_and_cancel_clean(bcx: block, dat: Datum) -> block {
 
 pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
     debug!("trans_to_datum(expr=%s)", bcx.expr_to_str(expr));
-
-    let mut bcx = bcx;
-    let mut datum = unpack_datum!(bcx, trans_to_datum_unadjusted(bcx, expr));
-    let adjustment = match bcx.tcx().adjustments.find_copy(&expr.id) {
-        None => { return DatumBlock {bcx: bcx, datum: datum}; }
-        Some(adj) => { adj }
-    };
-    debug!("unadjusted datum: %s", datum.to_str(bcx.ccx()));
-    match *adjustment {
-        AutoAddEnv(*) => {
-            datum = unpack_datum!(bcx, add_env(bcx, expr, datum));
+    return match bcx.tcx().adjustments.find(&expr.id) {
+        None => {
+            trans_to_datum_unadjusted(bcx, expr)
+        }
+        Some(&@AutoAddEnv(*)) => {
+            let mut bcx = bcx;
+            let datum = unpack_datum!(bcx, {
+                trans_to_datum_unadjusted(bcx, expr)
+            });
+            add_env(bcx, expr, datum)
         }
-        AutoDerefRef(ref adj) => {
+        Some(&@AutoDerefRef(ref adj)) => {
+            let mut bcx = bcx;
+            let mut datum = unpack_datum!(bcx, {
+                trans_to_datum_unadjusted(bcx, expr)
+            });
+
+            debug!("unadjusted datum: %s", datum.to_str(bcx.ccx()));
+
             if adj.autoderefs > 0 {
-                datum =
-                    unpack_datum!(
-                        bcx,
-                        datum.autoderef(bcx, expr.span,
-                                        expr.id, adj.autoderefs));
+                let DatumBlock { bcx: new_bcx, datum: new_datum } =
+                    datum.autoderef(bcx, expr.span, expr.id, adj.autoderefs);
+                datum = new_datum;
+                bcx = new_bcx;
             }
 
             datum = match adj.autoref {
@@ -219,31 +224,23 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
                     unpack_datum!(bcx, auto_slice_and_ref(bcx, expr, datum))
                 }
                 Some(AutoBorrowFn(*)) => {
-                    let adjusted_ty = ty::adjust_ty(bcx.tcx(), expr.span,
-                                                    datum.ty, Some(adjustment));
-                    unpack_datum!(bcx, auto_borrow_fn(bcx, adjusted_ty, datum))
+                    // currently, all closure types are
+                    // represented precisely the same, so no
+                    // runtime adjustment is required:
+                    datum
                 }
             };
+
+            debug!("after adjustments, datum=%s", datum.to_str(bcx.ccx()));
+
+            return DatumBlock {bcx: bcx, datum: datum};
         }
-    }
-    debug!("after adjustments, datum=%s", datum.to_str(bcx.ccx()));
-    return DatumBlock {bcx: bcx, datum: datum};
+    };
 
     fn auto_ref(bcx: block, datum: Datum) -> DatumBlock {
         DatumBlock {bcx: bcx, datum: datum.to_rptr(bcx)}
     }
 
-    fn auto_borrow_fn(bcx: block,
-                      adjusted_ty: ty::t,
-                      datum: Datum) -> DatumBlock {
-        // Currently, all closure types are represented precisely the
-        // same, so no runtime adjustment is required, but we still
-        // must patchup the type.
-        DatumBlock {bcx: bcx,
-                    datum: Datum {val: datum.val, ty: adjusted_ty,
-                                  mode: datum.mode, source: datum.source}}
-    }
-
     fn auto_slice(bcx: block, expr: @ast::expr, datum: Datum) -> DatumBlock {
         // This is not the most efficient thing possible; since slices
         // are two words it'd be better if this were compiled in

trunk/src/librustc/middle/ty.rs

@@ -2893,20 +2893,20 @@ pub fn expr_ty_adjusted(cx: ctxt, expr: @ast::expr) -> t {
      */
 
     let unadjusted_ty = expr_ty(cx, expr);
-    adjust_ty(cx, expr.span, unadjusted_ty, cx.adjustments.find_copy(&expr.id))
+    adjust_ty(cx, expr.span, unadjusted_ty, cx.adjustments.find(&expr.id))
 }
 
 pub fn adjust_ty(cx: ctxt,
                  span: span,
                  unadjusted_ty: ty::t,
-                 adjustment: Option<@AutoAdjustment>) -> ty::t
+                 adjustment: Option<&@AutoAdjustment>) -> ty::t
 {
     /*! See `expr_ty_adjusted` */
 
     return match adjustment {
         None => unadjusted_ty,
 
-        Some(@AutoAddEnv(r, s)) => {
+        Some(&@AutoAddEnv(r, s)) => {
             match ty::get(unadjusted_ty).sty {
                 ty::ty_bare_fn(ref b) => {
                     ty::mk_closure(
@@ -2924,7 +2924,7 @@ pub fn adjust_ty(cx: ctxt,
             }
         }
 
-        Some(@AutoDerefRef(ref adj)) => {
+        Some(&@AutoDerefRef(ref adj)) => {
             let mut adjusted_ty = unadjusted_ty;
 
             for uint::range(0, adj.autoderefs) |i| {

trunk/src/librustc/middle/typeck/check/regionck.rs

@@ -118,37 +118,22 @@ pub impl Rcx {
     }
 
     /// Try to resolve the type for the given node.
-    #[config(stage0)]
     fn resolve_expr_type_adjusted(@mut self, expr: @ast::expr) -> ty::t {
         let ty_unadjusted = self.resolve_node_type(expr.id);
         if ty::type_is_error(ty_unadjusted) || ty::type_is_bot(ty_unadjusted) {
             ty_unadjusted
         } else {
             let tcx = self.fcx.tcx();
             let adjustments = self.fcx.inh.adjustments;
-            match adjustments.find_copy(&expr.id) {
+            match adjustments.find(&expr.id) {
                 None => ty_unadjusted,
-                Some(adjustment) => {
-                    ty::adjust_ty(tcx, expr.span, ty_unadjusted,
-                                  Some(adjustment))
+                Some(&adjustment) => {
+                    // FIXME(#3850) --- avoid region scoping errors
+                    ty::adjust_ty(tcx, expr.span, ty_unadjusted, Some(&adjustment))
                 }
             }
         }
     }
-
-    /// Try to resolve the type for the given node.
-    #[config(not(stage0))]
-    fn resolve_expr_type_adjusted(@mut self, expr: @ast::expr) -> ty::t {
-        let ty_unadjusted = self.resolve_node_type(expr.id);
-        if ty::type_is_error(ty_unadjusted) || ty::type_is_bot(ty_unadjusted) {
-            ty_unadjusted
-        } else {
-            let tcx = self.fcx.tcx();
-            let adjustments = self.fcx.inh.adjustments;
-            ty::adjust_ty(tcx, expr.span, ty_unadjusted,
-                          adjustments.find_copy(&expr.id))
-        }
-    }
 }
 
 pub fn regionck_expr(fcx: @mut FnCtxt, e: @ast::expr) {
@@ -665,7 +650,7 @@ fn constrain_regions_in_type_of_node(
     // is going to fail anyway, so just stop here and let typeck
     // report errors later on in the writeback phase.
     let ty0 = rcx.resolve_node_type(id);
-    let adjustment = rcx.fcx.inh.adjustments.find_copy(&id);
+    let adjustment = rcx.fcx.inh.adjustments.find(&id);
     let ty = ty::adjust_ty(tcx, span, ty0, adjustment);
     debug!("constrain_regions_in_type_of_node(\
             ty=%s, ty0=%s, id=%d, minimum_lifetime=%?, adjustment=%?)",

trunk/src/rt/rust_task.cpp

@@ -76,8 +76,15 @@ rust_task::delete_this()
     assert(ref_count == 0); // ||
     //   (ref_count == 1 && this == sched->root_task));
 
-    // The borrow list should be freed in the task annihilator
-    assert(!borrow_list);
+    if (borrow_list) {
+        // NOTE should free borrow_list from within rust code!
+        // If there is a pointer in there, it is a ~[BorrowRecord] pointer,
+        // which are currently allocated with LIBC malloc/free. But this is
+        // not really the right way to do this, we should be freeing this
+        // pointer from Rust code.
+        free(borrow_list);
+        borrow_list = NULL;
+    }
 
     sched_loop->release_task(this);
 }

trunk/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs

@@ -0,0 +1,50 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests that the scope of the pointer returned from `get()` is
+// limited to the deref operation itself, and does not infect the
+// block as a whole.
+
+struct Box {
+    x: uint
+}
+
+impl Box {
+    fn get<'a>(&'a self) -> &'a uint {
+        &self.x
+    }
+    fn set(&mut self, x: uint) {
+        self.x = x;
+    }
+}
+
+fn fun1() {
+    // in the past, borrow checker behaved differently when
+    // init and decl of `v` were distinct
+    let v;
+    let mut box = Box {x: 0};
+    box.set(22);
+    v = *box.get();
+    box.set(v+1);
+    assert_eq!(23, *box.get());
+}
+
+fn fun2() {
+    let mut box = Box {x: 0};
+    box.set(22);
+    let v = *box.get();
+    box.set(v+1);
+    assert_eq!(23, *box.get());
+}
+
+pub fn main() {
+    fun1();
+    fun2();
+}