librustc: Remove @mut support from the typechecker and borrow checker

Author: pcwalton

src/librustc/driver/driver.rs

@@ -295,7 +295,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
          middle::liveness::check_crate(ty_cx, method_map,
                                        capture_map, crate));
 
-    let (root_map, write_guard_map) =
+    let root_map =
         time(time_passes, "borrow checking", (), |_|
              middle::borrowck::check_crate(ty_cx, method_map,
                                            moves_map, moved_variables_set,
@@ -330,7 +330,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
             root_map: root_map,
             method_map: method_map,
             vtable_map: vtable_map,
-            write_guard_map: write_guard_map,
             capture_map: capture_map
         },
         reachable: reachable_map

src/librustc/metadata/tydecode.rs

@@ -342,7 +342,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         let did = parse_def(st, TypeParameter, |x,y| conv(x,y));
         return ty::mk_self(st.tcx, did);
       }
-      '@' => return ty::mk_box(st.tcx, parse_mt(st, |x,y| conv(x,y))),
+      '@' => return ty::mk_box(st.tcx, parse_ty(st, |x,y| conv(x,y))),
       '~' => return ty::mk_uniq(st.tcx, parse_mt(st, |x,y| conv(x,y))),
       '*' => return ty::mk_ptr(st.tcx, parse_mt(st, |x,y| conv(x,y))),
       '&' => {

src/librustc/metadata/tyencode.rs

@@ -292,7 +292,7 @@ fn enc_sty(w: &mut MemWriter, cx: @ctxt, st: &ty::sty) {
             for t in ts.iter() { enc_ty(w, cx, *t); }
             mywrite!(w, "]");
         }
-        ty::ty_box(mt) => { mywrite!(w, "@"); enc_mt(w, cx, mt); }
+        ty::ty_box(typ) => { mywrite!(w, "@"); enc_ty(w, cx, typ); }
         ty::ty_uniq(mt) => { mywrite!(w, "~"); enc_mt(w, cx, mt); }
         ty::ty_ptr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); }
         ty::ty_rptr(r, mt) => {

src/librustc/middle/astencode.rs

@@ -55,7 +55,6 @@ pub struct Maps {
     root_map: middle::borrowck::root_map,
     method_map: middle::typeck::method_map,
     vtable_map: middle::typeck::vtable_map,
-    write_guard_map: middle::borrowck::write_guard_map,
     capture_map: middle::moves::CaptureMap,
 }
 

src/librustc/middle/borrowck/check_loans.rs

@@ -368,11 +368,15 @@ impl<'a> CheckLoanCtxt<'a> {
                         cmt = b;
                     }
 
+                    mc::cat_deref(_, _, mc::gc_ptr) => {
+                        assert_eq!(cmt.mutbl, mc::McImmutable);
+                        return;
+                    }
+
                     mc::cat_rvalue(..) |
                     mc::cat_static_item |
                     mc::cat_copied_upvar(..) |
                     mc::cat_deref(_, _, mc::unsafe_ptr(..)) |
-                    mc::cat_deref(_, _, mc::gc_ptr(..)) |
                     mc::cat_deref(_, _, mc::region_ptr(..)) => {
                         assert_eq!(cmt.mutbl, mc::McDeclared);
                         return;
@@ -411,20 +415,6 @@ impl<'a> CheckLoanCtxt<'a> {
                     check_for_aliasability_violation(this, expr, b);
                 }
 
-                mc::cat_deref(_, deref_count, mc::gc_ptr(ast::MutMutable)) => {
-                    // Dynamically check writes to `@mut`
-
-                    let key = root_map_key {
-                        id: guarantor.id,
-                        derefs: deref_count
-                    };
-                    debug!("Inserting write guard at {:?}", key);
-                    let mut write_guard_map = this.bccx
-                                                  .write_guard_map
-                                                  .borrow_mut();
-                    write_guard_map.get().insert(key);
-                }
-
                 _ => {}
             }
 
@@ -455,7 +445,7 @@ impl<'a> CheckLoanCtxt<'a> {
                     mc::cat_self(..) |
                     mc::cat_deref(_, _, mc::unsafe_ptr(..)) |
                     mc::cat_static_item(..) |
-                    mc::cat_deref(_, _, mc::gc_ptr(_)) |
+                    mc::cat_deref(_, _, mc::gc_ptr) |
                     mc::cat_deref(_, _, mc::region_ptr(MutImmutable, _)) => {
                         // Aliasability is independent of base cmt
                         match cmt.freely_aliasable() {

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

@@ -102,7 +102,7 @@ fn check_is_legal_to_move_from(bccx: &BorrowckCtxt,
                                cmt: mc::cmt) -> bool {
     match cmt.cat {
         mc::cat_deref(_, _, mc::region_ptr(..)) |
-        mc::cat_deref(_, _, mc::gc_ptr(..)) |
+        mc::cat_deref(_, _, mc::gc_ptr) |
         mc::cat_deref(_, _, mc::unsafe_ptr(..)) |
         mc::cat_stack_upvar(..) |
         mc::cat_copied_upvar(mc::CopiedUpvar { onceness: ast::Many, .. }) => {

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

@@ -16,10 +16,8 @@
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::ty;
-use syntax::ast::{MutImmutable, MutMutable};
 use syntax::ast;
 use syntax::codemap::Span;
-use util::ppaux::{note_and_explain_region};
 
 type R = Result<(),()>;
 
@@ -89,12 +87,11 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                 Ok(())
             }
 
-            mc::cat_deref(base, derefs, mc::gc_ptr(ptr_mutbl)) => {
+            mc::cat_deref(base, derefs, mc::gc_ptr) => {
                 let base_scope = self.scope(base);
 
                 // L-Deref-Managed-Imm-User-Root
                 let omit_root = (
-                    ptr_mutbl == MutImmutable &&
                     self.bccx.is_subregion_of(self.loan_region, base_scope) &&
                     self.is_rvalue_or_immutable(base) &&
                     !self.is_moved(base)
@@ -103,7 +100,7 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                 if !omit_root {
                     // L-Deref-Managed-Imm-Compiler-Root
                     // L-Deref-Managed-Mut-Compiler-Root
-                    self.check_root(cmt, base, derefs, ptr_mutbl, discr_scope)
+                    self.check_root(cmt, base, derefs, discr_scope)
                 } else {
                     debug!("omitting root, base={}, base_scope={:?}",
                            base.repr(self.tcx()), base_scope);
@@ -192,14 +189,12 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                   cmt_deref: mc::cmt,
                   cmt_base: mc::cmt,
                   derefs: uint,
-                  ptr_mutbl: ast::Mutability,
                   discr_scope: Option<ast::NodeId>) -> R {
-        debug!("check_root(cmt_deref={}, cmt_base={}, derefs={:?}, ptr_mutbl={:?}, \
+        debug!("check_root(cmt_deref={}, cmt_base={}, derefs={:?}, \
                 discr_scope={:?})",
                cmt_deref.repr(self.tcx()),
                cmt_base.repr(self.tcx()),
                derefs,
-               ptr_mutbl,
                discr_scope);
 
         // Make sure that the loan does not exceed the maximum time
@@ -235,19 +230,6 @@ impl<'a> GuaranteeLifetimeContext<'a> {
             }
         };
 
-        // If we are borrowing the inside of an `@mut` box,
-        // we need to dynamically mark it to prevent incompatible
-        // borrows from happening later.
-        let opt_dyna = match ptr_mutbl {
-            MutImmutable => None,
-            MutMutable => {
-                match self.loan_mutbl {
-                    MutableMutability => Some(DynaMut),
-                    ImmutableMutability | ConstMutability => Some(DynaImm)
-                }
-            }
-        };
-
         // FIXME(#3511) grow to the nearest cleanup scope---this can
         // cause observable errors if freezing!
         if !self.bccx.tcx.region_maps.is_cleanup_scope(root_scope) {
@@ -256,29 +238,12 @@ impl<'a> GuaranteeLifetimeContext<'a> {
             let cleanup_scope =
                 self.bccx.tcx.region_maps.cleanup_scope(root_scope);
 
-            if opt_dyna.is_some() {
-                self.tcx().sess.span_warn(
-                    self.span,
-                    format!("Dynamic freeze scope artifically extended \
-                          (see Issue \\#6248)"));
-                note_and_explain_region(
-                    self.bccx.tcx,
-                    "managed value only needs to be frozen for ",
-                    ty::ReScope(root_scope),
-                    "...");
-                note_and_explain_region(
-                    self.bccx.tcx,
-                    "...but due to Issue #6248, it will be frozen for ",
-                    ty::ReScope(cleanup_scope),
-                    "");
-            }
-
             root_scope = cleanup_scope;
         }
 
         // Add a record of what is required
         let rm_key = root_map_key {id: cmt_deref.id, derefs: derefs};
-        let root_info = RootInfo {scope: root_scope, freeze: opt_dyna};
+        let root_info = RootInfo {scope: root_scope};
 
         let mut root_map = self.bccx.root_map.borrow_mut();
         root_map.get().insert(rm_key, root_info);
@@ -357,7 +322,7 @@ impl<'a> GuaranteeLifetimeContext<'a> {
             }
             mc::cat_downcast(cmt) |
             mc::cat_deref(cmt, _, mc::uniq_ptr) |
-            mc::cat_deref(cmt, _, mc::gc_ptr(..)) |
+            mc::cat_deref(cmt, _, mc::gc_ptr) |
             mc::cat_interior(cmt, _) |
             mc::cat_stack_upvar(cmt) |
             mc::cat_discr(cmt, _) => {

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

@@ -132,59 +132,11 @@ impl<'a> RestrictionsContext<'a> {
                 Safe
             }
 
-            mc::cat_deref(_, _, mc::gc_ptr(MutImmutable)) => {
+            mc::cat_deref(_, _, mc::gc_ptr) => {
                 // R-Deref-Imm-Managed
                 Safe
             }
 
-            mc::cat_deref(cmt_base, _, pk @ mc::gc_ptr(MutMutable)) => {
-                // R-Deref-Managed-Borrowed
-                //
-                // Technically, no restrictions are *necessary* here.
-                // The validity of the borrow is guaranteed
-                // dynamically.  However, nonetheless we add a
-                // restriction to make a "best effort" to report
-                // static errors. For example, if there is code like
-                //
-                //    let v = @mut ~[1, 2, 3];
-                //    for e in v.iter() {
-                //        v.push(e + 1);
-                //    }
-                //
-                // Then the code below would add restrictions on `*v`,
-                // which means that an error would be reported
-                // here. This of course is not perfect. For example,
-                // a function like the following would not report an error
-                // at compile-time but would fail dynamically:
-                //
-                //    let v = @mut ~[1, 2, 3];
-                //    let w = v;
-                //    for e in v.iter() {
-                //        w.push(e + 1);
-                //    }
-                //
-                // In addition, we only add a restriction for those cases
-                // where we can construct a sensible loan path, so an
-                // example like the following will fail dynamically:
-                //
-                //    impl V {
-                //      fn get_list(&self) -> @mut ~[int];
-                //    }
-                //    ...
-                //    let v: &V = ...;
-                //    for e in v.get_list().iter() {
-                //        v.get_list().push(e + 1);
-                //    }
-                match opt_loan_path(cmt_base) {
-                    None => Safe,
-                    Some(lp_base) => {
-                        let lp = @LpExtend(lp_base, cmt.mutbl, LpDeref(pk));
-                        SafeIf(lp, ~[Restriction {loan_path: lp,
-                                                  set: restrictions}])
-                    }
-                }
-            }
-
             mc::cat_deref(cmt_base, _, pk @ mc::region_ptr(MutMutable, lt)) => {
                 // R-Deref-Mut-Borrowed
                 if !self.bccx.is_subregion_of(self.loan_region, lt) {

src/librustc/middle/borrowck/mod.rs

@@ -20,7 +20,7 @@ use middle::dataflow::DataFlowOperator;
 use util::ppaux::{note_and_explain_region, Repr, UserString};
 
 use std::cell::{Cell, RefCell};
-use std::hashmap::{HashSet, HashMap};
+use std::hashmap::HashMap;
 use std::ops::{BitOr, BitAnd};
 use std::result::{Result};
 use syntax::ast;
@@ -67,22 +67,20 @@ impl Visitor<()> for BorrowckCtxt {
     }
 }
 
-pub fn check_crate(
-    tcx: ty::ctxt,
-    method_map: typeck::method_map,
-    moves_map: moves::MovesMap,
-    moved_variables_set: moves::MovedVariablesSet,
-    capture_map: moves::CaptureMap,
-    crate: &ast::Crate) -> (root_map, write_guard_map)
-{
+pub fn check_crate(tcx: ty::ctxt,
+                   method_map: typeck::method_map,
+                   moves_map: moves::MovesMap,
+                   moved_variables_set: moves::MovedVariablesSet,
+                   capture_map: moves::CaptureMap,
+                   crate: &ast::Crate)
+                   -> root_map {
     let mut bccx = BorrowckCtxt {
         tcx: tcx,
         method_map: method_map,
         moves_map: moves_map,
         moved_variables_set: moved_variables_set,
         capture_map: capture_map,
         root_map: root_map(),
-        write_guard_map: @RefCell::new(HashSet::new()),
         stats: @BorrowStats {
             loaned_paths_same: Cell::new(0),
             loaned_paths_imm: Cell::new(0),
@@ -106,7 +104,7 @@ pub fn check_crate(
                  make_stat(bccx, bccx.stats.stable_paths.get()));
     }
 
-    return (bccx.root_map, bccx.write_guard_map);
+    return bccx.root_map;
 
     fn make_stat(bccx: &mut BorrowckCtxt, stat: uint) -> ~str {
         let stat_f = stat as f64;
@@ -171,7 +169,6 @@ pub struct BorrowckCtxt {
     moved_variables_set: moves::MovedVariablesSet,
     capture_map: moves::CaptureMap,
     root_map: root_map,
-    write_guard_map: write_guard_map,
 
     // Statistics:
     stats: @BorrowStats
@@ -213,10 +210,6 @@ pub struct root_map_key {
     derefs: uint
 }
 
-// A set containing IDs of expressions of gc'd type that need to have a write
-// guard.
-pub type write_guard_map = @RefCell<HashSet<root_map_key>>;
-
 pub type BckResult<T> = Result<T, BckError>;
 
 #[deriving(Eq)]
@@ -402,7 +395,6 @@ impl BitAnd<RestrictionSet,RestrictionSet> for RestrictionSet {
 
 pub struct RootInfo {
     scope: ast::NodeId,
-    freeze: Option<DynaFreezeKind> // Some() if we should freeze box at runtime
 }
 
 pub type root_map = @RefCell<HashMap<root_map_key, RootInfo>>;
@@ -411,20 +403,6 @@ pub fn root_map() -> root_map {
     return @RefCell::new(HashMap::new());
 }
 
-pub enum DynaFreezeKind {
-    DynaImm,
-    DynaMut
-}
-
-impl ToStr for DynaFreezeKind {
-    fn to_str(&self) -> ~str {
-        match *self {
-            DynaMut => ~"mutable",
-            DynaImm => ~"immutable"
-        }
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Errors
 
@@ -691,20 +669,9 @@ impl BorrowckCtxt {
                     span,
                     format!("{} in an aliasable location", prefix));
             }
-            mc::AliasableManaged(ast::MutMutable) => {
-                // FIXME(#6269) reborrow @mut to &mut
-                self.tcx.sess.span_err(
-                    span,
-                    format!("{} in a `@mut` pointer; \
-                          try borrowing as `&mut` first", prefix));
-            }
-            mc::AliasableManaged(m) => {
-                self.tcx.sess.span_err(
-                    span,
-                    format!("{} in a `@{}` pointer; \
-                          try an `@mut` instead",
-                         prefix,
-                         self.mut_to_keyword(m)));
+            mc::AliasableManaged => {
+                self.tcx.sess.span_err(span, format!("{} in a `@` pointer",
+                                                     prefix))
             }
             mc::AliasableBorrowed(m) => {
                 self.tcx.sess.span_err(