New scoping rules for safe destruction; not ready to land

src/compiletest/compiletest.rs

@@ -111,7 +111,10 @@ pub fn parse_config(args: Vec<String> ) -> Config {
     }
 
     fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
-        Path::new(m.opt_str(nm).unwrap())
+        match m.opt_str(nm) {
+            Some(s) => Path::new(s),
+            None => panic!("no option (=path) found for {}", nm),
+        }
     }
 
     let filter = if !matches.free.is_empty() {

src/liballoc/rc.rs

@@ -142,6 +142,14 @@
 //!     // destroyed. There are now no strong (Rc) references to the gadgets.
 //!     // Once they get destroyed, the Gadgets get destroyed. This zeroes the
 //!     // reference count on Gadget Man, so he gets destroyed as well.
+//!
+//!     // This is an unfortunate wart that is a side-effect of the implmentation
+//!     // of new destructor semantics: if the above for-loop is the final expression
+//!     // in the function, the borrow-checker treats the gadget_owner as needing to
+//!     // live past the destruction scope of the function (which of course it does not).
+//!     // To work around this, for now I am inserting a dummy value just so the above
+//!     // for-loop is no longer the final expression in the block.
+//!     ()
 //! }
 //! ```
 

src/libcollections/hash/sip.rs

@@ -490,8 +490,10 @@ mod tests {
         assert!(s != t && t != u);
         assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 
-        let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]);
-        let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]);
+        let (v1, v2, v3) = ([1u8], [0u8, 0], [0u8]);
+        let (w1, w2, w3) = ([1u8, 0, 0, 0], [], []);
+        let v: (&[u8], &[u8], &[u8]) = (&v1, &v2, &v3);
+        let w: (&[u8], &[u8], &[u8]) = (&w1, &w2, &w3);
 
         assert!(v != w);
         assert!(hash(&v) != hash(&w));

src/libcore/panicking.rs

@@ -64,6 +64,6 @@ pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
                         line: uint) -> !;
 
     }
-    let (file, line) = *file_line;
+    let (file, line) : (&'static str, uint) = *file_line;
     unsafe { panic_impl(fmt, file, line) }
 }

src/libregex/vm.rs

@@ -116,8 +116,10 @@ impl<'r, 't> Nfa<'r, 't> {
         };
         let mut matched = false;
         let ninsts = self.prog.insts.len();
-        let mut clist = &mut Threads::new(self.which, ninsts, ncaps);
-        let mut nlist = &mut Threads::new(self.which, ninsts, ncaps);
+        let mut cthread = Threads::new(self.which, ninsts, ncaps);
+        let mut nthread = Threads::new(self.which, ninsts, ncaps);
+        let mut clist = &mut cthread;
+        let mut nlist = &mut nthread;
 
         let mut groups = Vec::from_elem(ncaps * 2, None);
 

src/libregex_macros/lib.rs

@@ -183,8 +183,10 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
         fn run(&mut self, start: uint, end: uint) -> Vec<Option<uint>> {
             let mut matched = false;
             let prefix_bytes: &[u8] = $prefix_bytes;
-            let mut clist = &mut Threads::new(self.which);
-            let mut nlist = &mut Threads::new(self.which);
+            let mut cthread = Threads::new(self.which);
+            let mut nthread = Threads::new(self.which);
+            let mut clist = &mut cthread;
+            let mut nlist = &mut nthread;
 
             let mut groups = $init_groups;
 

src/librustc/metadata/tydecode.rs

@@ -344,6 +344,22 @@ fn parse_scope(st: &mut PState) -> region::CodeExtent {
             let node_id = parse_uint(st) as ast::NodeId;
             region::CodeExtent::Misc(node_id)
         }
+        'C' => {
+            let node_id = parse_uint(st) as ast::NodeId;
+            region::CodeExtent::Closure(node_id)
+        }
+        'D' => {
+            let node_id = parse_uint(st) as ast::NodeId;
+            region::CodeExtent::DestructionScope(node_id)
+        }
+        'B' => {
+            let node_id = parse_uint(st) as ast::NodeId;
+            let first_stmt_index = parse_uint(st);
+            let block_remainder = region::BlockRemainder {
+                block: node_id, first_statement_index: first_stmt_index,
+            };
+            region::CodeExtent::Remainder(block_remainder)
+        }
         _ => panic!("parse_scope: bad input")
     }
 }

src/librustc/metadata/tyencode.rs

@@ -170,7 +170,11 @@ pub fn enc_region(w: &mut SeekableMemWriter, cx: &ctxt, r: ty::Region) {
 
 fn enc_scope(w: &mut SeekableMemWriter, _cx: &ctxt, scope: region::CodeExtent) {
     match scope {
-        region::CodeExtent::Misc(node_id) => mywrite!(w, "M{}", node_id)
+        region::CodeExtent::Misc(node_id) => mywrite!(w, "M{}", node_id),
+        region::CodeExtent::Closure(node_id) => mywrite!(w, "C{}", node_id),
+        region::CodeExtent::Remainder(region::BlockRemainder {
+            block: b, first_statement_index: i }) => mywrite!(w, "B{}{}", b, i),
+        region::CodeExtent::DestructionScope(node_id) => mywrite!(w, "D{}", node_id),
     }
 }
 

src/librustc/middle/borrowck/check_loans.rs

@@ -239,6 +239,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
 
         let tcx = self.tcx();
         self.each_issued_loan(scope, |loan| {
+            debug!("each_in_scope_loan scope: {} loan: {} loan.kill_scope: {}",
+                   scope.repr(self.tcx()),
+                   loan.repr(self.tcx()),
+                   loan.kill_scope.repr(self.tcx()));
             if tcx.region_maps.is_subscope_of(scope, loan.kill_scope) {
                 op(loan)
             } else {
@@ -265,6 +269,11 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
         let loan_path = owned_ptr_base_path(loan_path);
         let cont = self.each_in_scope_loan(scope, |loan| {
             let mut ret = true;
+            debug!("each_in_scope_loan_affecting_path \
+                    scope: {} loan_path: {} restricted_paths: {}",
+                   scope.repr(self.tcx()),
+                   loan_path.repr(self.tcx()),
+                   loan.restricted_paths.repr(self.tcx()));
             for restr_path in loan.restricted_paths.iter() {
                 if **restr_path == *loan_path {
                     if !op(loan) {
@@ -304,6 +313,12 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
             }
 
             let cont = self.each_in_scope_loan(scope, |loan| {
+                debug!("each_in_scope_loan_affecting_path \
+                        scope: {} loan_path: {} loan: {}",
+                       scope.repr(self.tcx()),
+                       loan_path.repr(self.tcx()),
+                       loan.repr(self.tcx()));
+
                 if *loan.loan_path == *loan_path {
                     op(loan)
                 } else {

src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -96,46 +96,24 @@ impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
     fn check_scope(&self, max_scope: ty::Region) -> R {
         //! Reports an error if `loan_region` is larger than `max_scope`
 
+        debug!("check_scope self.loan_region: {} max_scope: {}",
+               self.loan_region.repr(self.bccx.tcx),
+               max_scope.repr(self.bccx.tcx));
         if !self.bccx.is_subregion_of(self.loan_region, max_scope) {
             Err(self.report_error(err_out_of_scope(max_scope, self.loan_region)))
         } else {
             Ok(())
         }
     }
 
-    fn scope(&self, cmt: &mc::cmt) -> ty::Region {
+    fn scope(&self, cmt: &mc::cmt<'tcx>) -> ty::Region {
         //! Returns the maximal region scope for the which the
         //! lvalue `cmt` is guaranteed to be valid without any
         //! rooting etc, and presuming `cmt` is not mutated.
 
         // See the SCOPE(LV) function in doc.rs
 
-        match cmt.cat {
-            mc::cat_rvalue(temp_scope) => {
-                temp_scope
-            }
-            mc::cat_upvar(..) => {
-                ty::ReScope(self.item_scope)
-            }
-            mc::cat_static_item => {
-                ty::ReStatic
-            }
-            mc::cat_local(local_id) => {
-                ty::ReScope(self.bccx.tcx.region_maps.var_scope(local_id))
-            }
-            mc::cat_deref(_, _, mc::UnsafePtr(..)) => {
-                ty::ReStatic
-            }
-            mc::cat_deref(_, _, mc::BorrowedPtr(_, r)) |
-            mc::cat_deref(_, _, mc::Implicit(_, r)) => {
-                r
-            }
-            mc::cat_downcast(ref cmt) |
-            mc::cat_deref(ref cmt, _, mc::OwnedPtr) |
-            mc::cat_interior(ref cmt, _) => {
-                self.scope(cmt)
-            }
-        }
+        mc::scope(self.bccx.tcx, cmt, self.item_scope)
     }
 
     fn report_error(&self, code: bckerr_code) {

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -474,6 +474,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> {
     fn visit_expr(&mut self, ex: &Expr) {
         match ex.node {
             ast::ExprAddrOf(mutbl, ref base) => {
+                debug!("StaticInitializerCtxt visit_expr ex: {}",
+                       ex.repr(self.bccx.tcx));
                 let base_cmt = self.bccx.cat_expr(&**base);
                 let borrow_kind = ty::BorrowKind::from_mutbl(mutbl);
                 // Check that we don't allow borrows of unsafe static items.

src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -105,6 +105,8 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
             }
 
             mc::cat_deref(cmt_base, _, pk) => {
+                debug!("restrict cat_deref (cmt={}) pk: {}",
+                       cmt.repr(self.bccx.tcx), pk);
                 match pk {
                     mc::OwnedPtr => {
                         // R-Deref-Send-Pointer

src/librustc/middle/expr_use_visitor.rs

@@ -285,6 +285,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                    assignment_expr: &ast::Expr,
                    expr: &ast::Expr,
                    mode: MutateMode) {
+        debug!("mutate_expr(expr={})", expr.repr(self.tcx()));
         let cmt = return_if_err!(self.mc.cat_expr(expr));
         self.delegate.mutate(assignment_expr.id, assignment_expr.span, cmt, mode);
         self.walk_expr(expr);
@@ -601,6 +602,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
     }
 
     fn walk_local(&mut self, local: &ast::Local) {
+        debug!("walk_local(local.id={})", local.id);
         match local.init {
             None => {
                 let delegate = &mut self.delegate;
@@ -643,6 +645,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                         _expr: &ast::Expr,
                         fields: &Vec<ast::Field>,
                         opt_with: &Option<P<ast::Expr>>) {
+        debug!("walk_struct_expr(_expr.id={})", _expr.id);
+
         // Consume the expressions supplying values for each field.
         for field in fields.iter() {
             self.consume_expr(&*field.expr);

src/librustc/middle/mem_categorization.rs

@@ -80,7 +80,7 @@ use middle::typeck;
 use util::nodemap::{DefIdMap, NodeMap};
 use util::ppaux::{ty_to_string, Repr};
 
-use syntax::ast::{MutImmutable, MutMutable};
+use syntax::ast::{MutImmutable, MutMutable, NodeId};
 use syntax::ast;
 use syntax::ast_map;
 use syntax::codemap::Span;
@@ -414,6 +414,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
     }
 
     pub fn cat_expr(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
+        debug!("cat_expr expr.id: {} {}", expr.id, expr);
         match self.typer.adjustments().borrow().get(&expr.id) {
             None => {
                 // No adjustments.
@@ -457,6 +458,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                                expr: &ast::Expr,
                                autoderefs: uint)
                                -> McResult<cmt<'tcx>> {
+        debug!("cat_expr_autoderefd: autoderefs={}", autoderefs);
         let mut cmt = if_ok!(self.cat_expr_unadjusted(expr));
         debug!("cat_expr_autoderefd: autoderefs={}, cmt={}",
                autoderefs,
@@ -468,9 +470,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
     }
 
     pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
-        debug!("cat_expr: id={} expr={}", expr.id, expr.repr(self.tcx()));
-
-        let expr_ty = if_ok!(self.expr_ty(expr));
+        debug!("cat_expr_unadjusted: id={} expr={}", expr.id, expr.repr(self.tcx()));
+
+        // let expr_ty = if_ok!(self.expr_ty(expr));
+        let expr_ty = match self.expr_ty(expr) {
+            Ok(expr_ty) => expr_ty,
+            Err(e) => {
+                debug!("cat_expr_unadjusted expr_ty errd");
+                return Err(e);
+            }
+        };
         match expr.node {
           ast::ExprUnary(ast::UnDeref, ref e_base) => {
             let base_cmt = if_ok!(self.cat_expr(&**e_base));
@@ -702,7 +711,10 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
 
             // Region of environment pointer
             let env_region = ty::ReFree(ty::FreeRegion {
-                scope: region::CodeExtent::from_node_id(fn_body_id),
+                // The environment of a closure is guaranteed to
+                // outlive any bindings introduced in the body of the
+                // closure itself.
+                scope: region::CodeExtent::DestructionScope(fn_body_id),
                 bound_region: ty::BrEnv
             });
 
@@ -1543,3 +1555,34 @@ fn element_kind(t: Ty) -> ElementKind {
         _ => OtherElement
     }
 }
+
+
+/// Returns the maximal region scope for the which the lvalue `cmt` is
+/// guaranteed to be valid without any rooting etc, and presuming `cmt`
+/// is not mutated. See the `SCOPE(LV)` function in `borrowck/doc.rs`.
+pub fn scope<'tcx>(tcx: &ty::ctxt<'tcx>,
+                   cmt: &cmt<'tcx>,
+                   extent: region::CodeExtent) -> ty::Region {
+    let ret = match cmt.cat {
+        cat_rvalue(temp_scope) => temp_scope,
+        cat_upvar(..) => ty::ReScope(extent),
+
+        cat_static_item => ty::ReStatic,
+
+        cat_local(local_id) => {
+            ty::ReScope(tcx.region_maps.var_scope(local_id))
+        }
+
+        cat_deref(_, _, UnsafePtr(..)) => ty::ReStatic,
+
+        cat_deref(_, _, BorrowedPtr(_, r)) |
+        cat_deref(_, _, Implicit(_, r)) => r,
+
+        cat_downcast(ref cmt) |
+        cat_deref(ref cmt, _, OwnedPtr) |
+        cat_interior(ref cmt, _) => scope(tcx, cmt, extent),
+    };
+    debug!("scope cmt: {} {} return: {}", cmt, cmt.repr(tcx), ret);
+    return ret;
+}
+