Adding support for regions in unsafe pointers

doc/tutorial-ffi.md

@@ -156,13 +156,13 @@ use std::unstable::intrinsics;
 
 // a wrapper around the handle returned by the foreign code
 pub struct Unique<T> {
-    priv ptr: *mut T
+    priv ptr: *'static mut T
 }
 
 impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {
-            let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
+            let ptr = malloc(std::sys::size_of::<T>() as size_t) as *'static mut T;
             assert!(!ptr::is_null(ptr));
             // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
             intrinsics::move_val_init(&mut *ptr, value);

src/libextra/arc.rs

@@ -272,7 +272,7 @@ fn check_poison(is_mutex: bool, failed: bool) {
 
 #[doc(hidden)]
 struct PoisonOnFail {
-    failed: *mut bool,
+    failed: *'static mut bool,
 }
 
 impl Drop for PoisonOnFail {

src/libextra/c_vec.rs

@@ -45,7 +45,7 @@ use std::ptr;
  *
  */
 pub struct CVec<T> {
-    priv base: *mut T,
+    priv base: *'static mut T,
     priv len: uint,
     priv rsrc: @DtorRes
 }
@@ -82,12 +82,12 @@ fn DtorRes(dtor: Option<@fn()>) -> DtorRes {
  * * base - A foreign pointer to a buffer
  * * len - The number of elements in the buffer
  */
-pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
-    return CVec{
+pub unsafe fn CVec<T>(base: *'static mut T, len: uint) -> CVec<T> {
+    CVec {
         base: base,
         len: len,
         rsrc: @DtorRes(option::None)
-    };
+    }
 }
 
 /**
@@ -101,13 +101,12 @@ pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
  * * dtor - A function to run when the value is destructed, useful
  *          for freeing the buffer, etc.
  */
-pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: @fn())
-  -> CVec<T> {
-    return CVec{
+pub unsafe fn c_vec_with_dtor<T>(base: *'static mut T, len: uint, dtor: @fn()) -> CVec<T> {
+    CVec {
         base: base,
         len: len,
         rsrc: @DtorRes(option::Some(dtor))
-    };
+    }
 }
 
 /*

src/libextra/dlist.rs

@@ -38,7 +38,7 @@ pub struct DList<T> {
 }
 
 type Link<T> = Option<~Node<T>>;
-struct Rawlink<T> { priv p: *mut T }
+struct Rawlink<T> { priv p: *'static mut T }
 
 struct Node<T> {
     priv next: Link<T>,
@@ -77,7 +77,11 @@ impl<T> Rawlink<T> {
 
     /// Like Option::Some for Rawlink
     fn some(n: &mut T) -> Rawlink<T> {
-        Rawlink{p: ptr::to_mut_unsafe_ptr(n)}
+        unsafe {
+            Rawlink {
+                p: cast::transmute(ptr::to_mut_unsafe_ptr(n))
+            }
+        }
     }
 
     /// Convert the `Rawlink` into an Option value

src/libextra/future.rs

@@ -194,7 +194,7 @@ mod test {
 
     #[test]
     fn test_interface_unwrap() {
-        let mut f = from_value(~"fail");
+        let f = from_value(~"fail");
         assert_eq!(f.unwrap(), ~"fail");
     }
 

src/libextra/rc.rs

@@ -37,7 +37,7 @@ struct RcBox<T> {
 #[unsafe_no_drop_flag]
 #[no_send]
 pub struct Rc<T> {
-    priv ptr: *mut RcBox<T>,
+    priv ptr: *'static mut RcBox<T>,
 }
 
 impl<T> Rc<T> {
@@ -170,7 +170,7 @@ struct RcMutBox<T> {
 #[no_freeze]
 #[unsafe_no_drop_flag]
 pub struct RcMut<T> {
-    priv ptr: *mut RcMutBox<T>,
+    priv ptr: *'static mut RcMutBox<T>,
 }
 
 impl<T> RcMut<T> {

src/librustc/lib/llvm.rs

@@ -194,41 +194,41 @@ pub enum AsmDialect {
 
 // Opaque pointer types
 pub enum Module_opaque {}
-pub type ModuleRef = *Module_opaque;
+pub type ModuleRef = *'static Module_opaque;
 pub enum Context_opaque {}
-pub type ContextRef = *Context_opaque;
+pub type ContextRef = *'static Context_opaque;
 pub enum Type_opaque {}
-pub type TypeRef = *Type_opaque;
+pub type TypeRef = *'static Type_opaque;
 pub enum Value_opaque {}
-pub type ValueRef = *Value_opaque;
+pub type ValueRef = *'static Value_opaque;
 pub enum BasicBlock_opaque {}
-pub type BasicBlockRef = *BasicBlock_opaque;
+pub type BasicBlockRef = *'static BasicBlock_opaque;
 pub enum Builder_opaque {}
-pub type BuilderRef = *Builder_opaque;
+pub type BuilderRef = *'static Builder_opaque;
 pub enum ExecutionEngine_opaque {}
-pub type ExecutionEngineRef = *ExecutionEngine_opaque;
+pub type ExecutionEngineRef = *'static ExecutionEngine_opaque;
 pub enum MemoryBuffer_opaque {}
-pub type MemoryBufferRef = *MemoryBuffer_opaque;
+pub type MemoryBufferRef = *'static MemoryBuffer_opaque;
 pub enum PassManager_opaque {}
-pub type PassManagerRef = *PassManager_opaque;
+pub type PassManagerRef = *'static PassManager_opaque;
 pub enum PassManagerBuilder_opaque {}
-pub type PassManagerBuilderRef = *PassManagerBuilder_opaque;
+pub type PassManagerBuilderRef = *'static PassManagerBuilder_opaque;
 pub enum Use_opaque {}
-pub type UseRef = *Use_opaque;
+pub type UseRef = *'static Use_opaque;
 pub enum TargetData_opaque {}
-pub type TargetDataRef = *TargetData_opaque;
+pub type TargetDataRef = *'static TargetData_opaque;
 pub enum ObjectFile_opaque {}
-pub type ObjectFileRef = *ObjectFile_opaque;
+pub type ObjectFileRef = *'static ObjectFile_opaque;
 pub enum SectionIterator_opaque {}
-pub type SectionIteratorRef = *SectionIterator_opaque;
+pub type SectionIteratorRef = *'static SectionIterator_opaque;
 pub enum Pass_opaque {}
-pub type PassRef = *Pass_opaque;
+pub type PassRef = *'static Pass_opaque;
 
 pub mod debuginfo {
     use super::{ValueRef};
 
     pub enum DIBuilder_opaque {}
-    pub type DIBuilderRef = *DIBuilder_opaque;
+    pub type DIBuilderRef = *'static DIBuilder_opaque;
 
     pub type DIDescriptor = ValueRef;
     pub type DIScope = DIDescriptor;

src/librustc/metadata/tydecode.rs

@@ -326,7 +326,11 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
       }
       '@' => return ty::mk_box(st.tcx, parse_mt(st, conv)),
       '~' => return ty::mk_uniq(st.tcx, parse_mt(st, conv)),
-      '*' => return ty::mk_ptr(st.tcx, parse_mt(st, conv)),
+      '*' => {
+        let r = parse_region(st);
+        let mt = parse_mt(st, conv);
+        return ty::mk_ptr(st.tcx, r, mt);
+      }
       '&' => {
         let r = parse_region(st);
         let mt = parse_mt(st, conv);

src/librustc/metadata/tyencode.rs

@@ -278,7 +278,11 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, st: &ty::sty) {
       }
       ty::ty_box(mt) => { w.write_char('@'); enc_mt(w, cx, mt); }
       ty::ty_uniq(mt) => { w.write_char('~'); enc_mt(w, cx, mt); }
-      ty::ty_ptr(mt) => { w.write_char('*'); enc_mt(w, cx, mt); }
+      ty::ty_ptr(r, mt) => {
+        w.write_char('*');
+        enc_region(w, cx, r);
+        enc_mt(w, cx, mt);
+      }
       ty::ty_rptr(r, mt) => {
         w.write_char('&');
         enc_region(w, cx, r);

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

@@ -74,7 +74,7 @@ impl GuaranteeLifetimeContext {
             mc::cat_arg(*) |                           // L-Local
             mc::cat_self(*) |                          // L-Local
             mc::cat_deref(_, _, mc::region_ptr(*)) |   // L-Deref-Borrowed
-            mc::cat_deref(_, _, mc::unsafe_ptr) => {
+            mc::cat_deref(_, _, mc::unsafe_ptr(*)) => {
                 let scope = self.scope(cmt);
                 self.check_scope(scope)
             }

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

@@ -357,7 +357,7 @@ impl GatherLoanCtxt {
                                              m_imm,
                                              r)
                     }
-                    ty::AutoUnsafe(_) => {}
+                    ty::AutoUnsafe(*) => {}
                 }
             }
         }

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

@@ -194,7 +194,7 @@ impl RestrictionsContext {
                 }
             }
 
-            mc::cat_deref(_, _, mc::unsafe_ptr) => {
+            mc::cat_deref(_, _, mc::unsafe_ptr(*)) => {
                 // We are very trusting when working with unsafe pointers.
                 Safe
             }

src/librustc/middle/effect.rs

@@ -133,7 +133,7 @@ pub fn check_crate(tcx: ty::ctxt,
                     debug!("effect: unary case, base type is %s",
                            ppaux::ty_to_str(tcx, base_type));
                     match ty::get(base_type).sty {
-                        ty_ptr(_) => {
+                        ty_ptr(*) => {
                             require_unsafe(expr.span,
                                            "dereference of unsafe pointer")
                         }

src/librustc/middle/lint.rs

@@ -725,7 +725,9 @@ fn check_item_ctypes(cx: &Context, it: &ast::item) {
                     _ => ()
                 }
             }
-            ast::ty_ptr(ref mt) => { check_ty(cx, mt.ty) }
+            ast::ty_ptr(_, ref mt) => {
+                check_ty(cx, mt.ty)
+            }
             _ => ()
         }
     }

src/librustc/middle/mem_categorization.rs

@@ -88,7 +88,7 @@ pub enum ptr_kind {
     uniq_ptr(ast::mutability),
     gc_ptr(ast::mutability),
     region_ptr(ast::mutability, ty::Region),
-    unsafe_ptr
+    unsafe_ptr(ty::Region),
 }
 
 // We use the term "interior" to mean "something reachable from the
@@ -188,8 +188,8 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             Some(deref_ptr(gc_ptr(ast::m_imm)))
         }
 
-        ty::ty_ptr(*) => {
-            Some(deref_ptr(unsafe_ptr))
+        ty::ty_ptr(r, _) => {
+            Some(deref_ptr(unsafe_ptr(r)))
         }
 
         ty::ty_enum(*) |
@@ -678,7 +678,7 @@ impl mem_categorization_ctxt {
                     uniq_ptr(*) => {
                         self.inherited_mutability(base_cmt.mutbl, mt.mutbl)
                     }
-                    gc_ptr(*) | region_ptr(_, _) | unsafe_ptr => {
+                    gc_ptr(*) | region_ptr(*) | unsafe_ptr(*) => {
                         MutabilityCategory::from_mutbl(mt.mutbl)
                     }
                 };
@@ -759,7 +759,7 @@ impl mem_categorization_ctxt {
               uniq_ptr(*) => {
                 self.inherited_mutability(base_cmt.mutbl, mt.mutbl)
               }
-              gc_ptr(_) | region_ptr(_, _) | unsafe_ptr => {
+              gc_ptr(_) | region_ptr(*) | unsafe_ptr(*) => {
                 MutabilityCategory::from_mutbl(mt.mutbl)
               }
             };
@@ -1232,7 +1232,7 @@ pub fn ptr_sigil(ptr: ptr_kind) -> ~str {
         uniq_ptr(_) => ~"~",
         gc_ptr(_) => ~"@",
         region_ptr(_, _) => ~"&",
-        unsafe_ptr => ~"*"
+        unsafe_ptr(*) => ~"*"
     }
 }
 

src/librustc/middle/region.rs

@@ -748,6 +748,16 @@ fn determine_rp_in_ty(ty: &ast::Ty,
     // locations)
     let sess = cx.sess;
     match ty.node {
+        ast::ty_ptr(ref r, _) => {
+            debug!("referenced ptr type %s",
+                   pprust::ty_to_str(ty, sess.intr()));
+
+            if cx.region_is_relevant(r) {
+                let rv = cx.add_variance(rv_contravariant);
+                cx.add_rp(cx.item_id, rv)
+            }
+        }
+
         ast::ty_rptr(ref r, _) => {
             debug!("referenced rptr type %s",
                    pprust::ty_to_str(ty, sess.intr()));
@@ -817,7 +827,7 @@ fn determine_rp_in_ty(ty: &ast::Ty,
 
     match ty.node {
       ast::ty_box(ref mt) | ast::ty_uniq(ref mt) | ast::ty_vec(ref mt) |
-      ast::ty_rptr(_, ref mt) | ast::ty_ptr(ref mt) => {
+      ast::ty_rptr(_, ref mt) | ast::ty_ptr(_, ref mt) => {
         visit_mt(mt, (cx, visitor));
       }
 

src/librustc/middle/trans/_match.rs

@@ -1279,8 +1279,6 @@ pub fn compile_submatch(bcx: block,
     assert!((m.len() > 0u || chk.is_some()));
     let _icx = push_ctxt("match::compile_submatch");
     let mut bcx = bcx;
-    let tcx = bcx.tcx();
-    let dm = tcx.def_map;
     if m.len() == 0u {
         Br(bcx, chk.get()());
         return;

src/librustc/middle/trans/base.rs

@@ -572,7 +572,7 @@ pub fn compare_scalar_types(cx: block,
 
     match ty::get(t).sty {
         ty::ty_nil => rslt(cx, f(nil_type)),
-        ty::ty_bool | ty::ty_ptr(_) => rslt(cx, f(unsigned_int)),
+        ty::ty_bool | ty::ty_ptr(*) => rslt(cx, f(unsigned_int)),
         ty::ty_int(_) => rslt(cx, f(signed_int)),
         ty::ty_uint(_) => rslt(cx, f(unsigned_int)),
         ty::ty_float(_) => rslt(cx, f(floating_point)),

src/librustc/middle/trans/closure.rs

@@ -148,7 +148,9 @@ pub fn mk_closure_tys(tcx: ty::ctxt,
     let bound_tys = bound_values.map(|bv| {
         match bv.action {
             EnvCopy | EnvMove => bv.datum.ty,
-            EnvRef => ty::mk_mut_ptr(tcx, bv.datum.ty)
+            EnvRef => ty::mk_mut_ptr(tcx,
+                                     ty::re_static,
+                                     bv.datum.ty)
         }
     });
     let cdata_ty = ty::mk_tup(tcx, bound_tys);
@@ -210,7 +212,9 @@ pub fn store_environment(bcx: block,
     // tuple.  This could be a ptr in uniq or a box or on stack,
     // whatever.
     let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
-    let cboxptr_ty = ty::mk_ptr(tcx, ty::mt {ty:cbox_ty, mutbl:ast::m_imm});
+    let cboxptr_ty = ty::mk_ptr(tcx,
+                                ty::re_static,
+                                ty::mt {ty:cbox_ty, mutbl:ast::m_imm});
     let llboxptr_ty = type_of(ccx, cboxptr_ty);
 
     // If there are no bound values, no point in allocating anything.

src/librustc/middle/trans/common.rs

@@ -683,6 +683,7 @@ impl block_ {
 pub fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
     let ptr = ty::mk_ptr(
         tcx,
+        ty::re_static,
         ty::mt {ty: ty::mk_i8(), mutbl: ast::m_imm}
     );
     return ty::mk_tup(tcx, ~[ty::mk_uint(), ty::mk_type(tcx),

src/librustc/middle/trans/consts.rs

@@ -205,7 +205,7 @@ pub fn const_expr(cx: @mut CrateContext, e: @ast::expr) -> ValueRef {
                         None => const_addr_of(cx, llconst)
                     };
                     match *autoref {
-                        ty::AutoUnsafe(m) |
+                        ty::AutoUnsafe(_, m) |
                         ty::AutoPtr(ty::re_static, m) => {
                             assert!(m != ast::m_mutbl);
                             llconst = llptr;

src/librustc/middle/trans/datum.rs

@@ -631,7 +631,7 @@ impl Datum {
             ty::ty_box(_) | ty::ty_uniq(_) => {
                 return (Some(self.box_body(bcx)), bcx);
             }
-            ty::ty_ptr(mt) => {
+            ty::ty_ptr(_, mt) => {
                 if is_auto { // unsafe ptrs are not AUTO-derefable
                     return (None, bcx);
                 } else {