---

yaml
---
r: 65150
b: refs/heads/master
c: 32e30aa
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 474d9983beb8a5770a202c552f36c14fa52917a2
+refs/heads/master: 32e30aaa00d098d81fd269d48845cbfd95d20710
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libcore/cast.rs

@@ -12,26 +12,17 @@
 
 use sys;
 use unstable;
-
-pub mod rusti {
-    #[abi = "rust-intrinsic"]
-    #[link_name = "rusti"]
-    pub extern "rust-intrinsic" {
-        fn forget<T>(x: T);
-
-        fn transmute<T,U>(e: T) -> U;
-    }
-}
+use unstable::intrinsics;
 
 /// Casts the value at `src` to U. The two types must have the same length.
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = unstable::intrinsics::init();
+    let mut dest: U = intrinsics::init();
     {
-        let dest_ptr: *mut u8 = rusti::transmute(&mut dest);
-        let src_ptr: *u8 = rusti::transmute(src);
-        unstable::intrinsics::memmove64(dest_ptr,
-                                        src_ptr,
-                                        sys::size_of::<U>() as u64);
+        let dest_ptr: *mut u8 = transmute(&mut dest);
+        let src_ptr: *u8 = transmute(src);
+        intrinsics::memmove64(dest_ptr,
+                              src_ptr,
+                              sys::size_of::<U>() as u64);
     }
     dest
 }
@@ -45,7 +36,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
  * reinterpret_cast on pointer types.
  */
 #[inline(always)]
-pub unsafe fn forget<T>(thing: T) { rusti::forget(thing); }
+pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing); }
 
 /**
  * Force-increment the reference count on a shared box. If used
@@ -65,7 +56,7 @@ pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
  */
 #[inline(always)]
 pub unsafe fn transmute<L, G>(thing: L) -> G {
-    rusti::transmute(thing)
+    intrinsics::transmute(thing)
 }
 
 /// Coerce an immutable reference to be mutable.

trunk/src/libcore/clone.rs

@@ -25,8 +25,9 @@ by convention implementing the `Clone` trait and calling the
 use core::kinds::Const;
 
 pub trait Clone {
-    /// Return a deep copy of the owned object tree. Types with shared ownership like managed boxes
-    /// are cloned with a shallow copy.
+    /// Returns a copy of the value. The contents of owned pointers
+    /// are copied to maintain uniqueness, while the contents of
+    /// managed pointers are not copied.
     fn clone(&self) -> Self;
 }
 
@@ -85,8 +86,9 @@ clone_impl!(bool)
 clone_impl!(char)
 
 pub trait DeepClone {
-    /// Return a deep copy of the object tree. Types with shared ownership are also copied via a
-    /// deep copy, unlike `Clone`.
+    /// Return a deep copy of the value. Unlike `Clone`, the contents of shared pointer types
+    /// *are* copied. Note that this is currently unimplemented for managed boxes, as
+    /// it would need to handle cycles, but it is implemented for other smart-pointer types.
     fn deep_clone(&self) -> Self;
 }
 

trunk/src/libcore/stackwalk.rs

@@ -11,6 +11,7 @@
 #[doc(hidden)]; // FIXME #3538
 
 use cast::transmute;
+use unstable::intrinsics;
 
 pub type Word = uint;
 
@@ -75,13 +76,6 @@ fn test_simple_deep() {
 
 fn frame_address(f: &fn(x: *u8)) {
     unsafe {
-        rusti::frame_address(f)
-    }
-}
-
-pub mod rusti {
-    #[abi = "rust-intrinsic"]
-    pub extern "rust-intrinsic" {
-        pub fn frame_address(f: &once fn(x: *u8));
+        intrinsics::frame_address(f)
     }
 }

trunk/src/libcore/sys.rs

@@ -19,6 +19,7 @@ use libc;
 use libc::{c_void, c_char, size_t};
 use repr;
 use str;
+use unstable::intrinsics;
 
 pub type FreeGlue<'self> = &'self fn(*TypeDesc, *c_void);
 
@@ -38,16 +39,6 @@ pub struct Closure {
     env: *(),
 }
 
-pub mod rusti {
-    #[abi = "rust-intrinsic"]
-    pub extern "rust-intrinsic" {
-        fn get_tydesc<T>() -> *();
-        fn size_of<T>() -> uint;
-        fn pref_align_of<T>() -> uint;
-        fn min_align_of<T>() -> uint;
-    }
-}
-
 pub mod rustrt {
     use libc::{c_char, size_t};
 
@@ -81,7 +72,7 @@ pub fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
  */
 #[inline(always)]
 pub fn get_type_desc<T>() -> *TypeDesc {
-    unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
+    unsafe { intrinsics::get_tydesc::<T>() as *TypeDesc }
 }
 
 /// Returns a pointer to a type descriptor.
@@ -93,7 +84,7 @@ pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
 /// Returns the size of a type
 #[inline(always)]
 pub fn size_of<T>() -> uint {
-    unsafe { rusti::size_of::<T>() }
+    unsafe { intrinsics::size_of::<T>() }
 }
 
 /// Returns the size of the type that `_val` points to
@@ -128,7 +119,7 @@ pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
  */
 #[inline(always)]
 pub fn min_align_of<T>() -> uint {
-    unsafe { rusti::min_align_of::<T>() }
+    unsafe { intrinsics::min_align_of::<T>() }
 }
 
 /// Returns the ABI-required minimum alignment of the type of the value that
@@ -141,7 +132,7 @@ pub fn min_align_of_val<T>(_val: &T) -> uint {
 /// Returns the preferred alignment of a type
 #[inline(always)]
 pub fn pref_align_of<T>() -> uint {
-    unsafe { rusti::pref_align_of::<T>() }
+    unsafe { intrinsics::pref_align_of::<T>() }
 }
 
 /// Returns the preferred alignment of the type of the value that

trunk/src/libcore/unstable/intrinsics.rs

@@ -114,15 +114,16 @@ pub extern "rust-intrinsic" {
     /// `forget` is unsafe because the caller is responsible for
     /// ensuring the argument is deallocated already.
     pub unsafe fn forget<T>(_: T) -> ();
+    pub fn transmute<T,U>(e: T) -> U;
 
     /// Returns `true` if a type requires drop glue.
     pub fn needs_drop<T>() -> bool;
 
     // XXX: intrinsic uses legacy modes and has reference to TyDesc
     // and TyVisitor which are in librustc
     //fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor) -> ();
-    // XXX: intrinsic uses legacy modes
-    //fn frame_address(f: &once fn(*u8));
+
+    pub fn frame_address(f: &once fn(*u8));
 
     /// Get the address of the `__morestack` stack growth function.
     pub fn morestack_addr() -> *();

trunk/src/librustc/lib/llvm.rs

@@ -1571,15 +1571,13 @@ pub mod llvm {
         pub unsafe fn LLVMBuildAtomicLoad(B: BuilderRef,
                                           PointerVal: ValueRef,
                                           Name: *c_char,
-                                          Order: AtomicOrdering,
-                                          Alignment: c_uint)
+                                          Order: AtomicOrdering)
                                        -> ValueRef;
 
         pub unsafe fn LLVMBuildAtomicStore(B: BuilderRef,
                                            Val: ValueRef,
                                            Ptr: ValueRef,
-                                           Order: AtomicOrdering,
-                                           Alignment: c_uint)
+                                           Order: AtomicOrdering)
                                         -> ValueRef;
 
         pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef,

trunk/src/librustc/middle/borrowck/check_loans.rs

@@ -343,6 +343,7 @@ pub impl<'self> CheckLoanCtxt<'self> {
                         cmt = b;
                     }
 
+                    mc::cat_downcast(b) |
                     mc::cat_interior(b, _) => {
                         if cmt.mutbl == mc::McInherited {
                             cmt = b;

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

@@ -104,6 +104,7 @@ impl GuaranteeLifetimeContext {
                 }
             }
 
+            mc::cat_downcast(base) |
             mc::cat_deref(base, _, mc::uniq_ptr(*)) |
             mc::cat_interior(base, _) => {
                 self.check(base, discr_scope)
@@ -302,6 +303,7 @@ impl GuaranteeLifetimeContext {
             mc::cat_deref(*) => {
                 false
             }
+            r @ mc::cat_downcast(*) |
             r @ mc::cat_interior(*) |
             r @ mc::cat_stack_upvar(*) |
             r @ mc::cat_discr(*) => {
@@ -339,6 +341,7 @@ impl GuaranteeLifetimeContext {
             mc::cat_deref(_, _, mc::region_ptr(_, r)) => {
                 r
             }
+            mc::cat_downcast(cmt) |
             mc::cat_deref(cmt, _, mc::uniq_ptr(*)) |
             mc::cat_deref(cmt, _, mc::gc_ptr(*)) |
             mc::cat_interior(cmt, _) |

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

@@ -79,24 +79,17 @@ impl RestrictionsContext {
                                           set: restrictions}])
             }
 
-            mc::cat_interior(cmt_base, i @ mc::interior_variant(_)) => {
+            mc::cat_downcast(cmt_base) => {
                 // When we borrow the interior of an enum, we have to
                 // ensure the enum itself is not mutated, because that
                 // could cause the type of the memory to change.
-                let result = self.compute(cmt_base, restrictions | RESTR_MUTATE);
-                self.extend(result, cmt.mutbl, LpInterior(i), restrictions)
+                self.compute(cmt_base, restrictions | RESTR_MUTATE)
             }
 
-            mc::cat_interior(cmt_base, i @ mc::interior_tuple) |
-            mc::cat_interior(cmt_base, i @ mc::interior_anon_field) |
-            mc::cat_interior(cmt_base, i @ mc::interior_field(*)) |
-            mc::cat_interior(cmt_base, i @ mc::interior_index(*)) => {
-                // For all of these cases, overwriting the base would
-                // not change the type of the memory, so no additional
-                // restrictions are needed.
-                //
-                // FIXME(#5397) --- Mut fields are not treated soundly
-                //                  (hopefully they will just get phased out)
+            mc::cat_interior(cmt_base, i) => {
+                // Overwriting the base would not change the type of
+                // the memory, so no additional restrictions are
+                // needed.
                 let result = self.compute(cmt_base, restrictions);
                 self.extend(result, cmt.mutbl, LpInterior(i), restrictions)
             }

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

@@ -232,8 +232,8 @@ pub enum LoanPath {
 
 #[deriving(Eq)]
 pub enum LoanPathElem {
-    LpDeref,                      // `*LV` in doc.rs
-    LpInterior(mc::interior_kind) // `LV.f` in doc.rs
+    LpDeref,                     // `*LV` in doc.rs
+    LpInterior(mc::InteriorKind) // `LV.f` in doc.rs
 }
 
 pub impl LoanPath {
@@ -276,6 +276,7 @@ pub fn opt_loan_path(cmt: mc::cmt) -> Option<@LoanPath> {
                 |&lp| @LpExtend(lp, cmt.mutbl, LpInterior(ik)))
         }
 
+        mc::cat_downcast(cmt_base) |
         mc::cat_stack_upvar(cmt_base) |
         mc::cat_discr(cmt_base, _) => {
             opt_loan_path(cmt_base)
@@ -612,24 +613,25 @@ pub impl BorrowckCtxt {
                 }
             }
 
-            LpExtend(lp_base, _, LpInterior(mc::interior_field(fld))) => {
+            LpExtend(lp_base, _, LpInterior(mc::InteriorField(fname))) => {
                 self.append_loan_path_to_str_from_interior(lp_base, out);
-                str::push_char(out, '.');
-                str::push_str(out, *self.tcx.sess.intr().get(fld));
+                match fname {
+                    mc::NamedField(fname) => {
+                        str::push_char(out, '.');
+                        str::push_str(out, *self.tcx.sess.intr().get(fname));
+                    }
+                    mc::PositionalField(idx) => {
+                        str::push_char(out, '#'); // invent a notation here
+                        str::push_str(out, idx.to_str());
+                    }
+                }
             }
 
-            LpExtend(lp_base, _, LpInterior(mc::interior_index(*))) => {
+            LpExtend(lp_base, _, LpInterior(mc::InteriorElement(_))) => {
                 self.append_loan_path_to_str_from_interior(lp_base, out);
                 str::push_str(out, "[]");
             }
 
-            LpExtend(lp_base, _, LpInterior(mc::interior_tuple)) |
-            LpExtend(lp_base, _, LpInterior(mc::interior_anon_field)) |
-            LpExtend(lp_base, _, LpInterior(mc::interior_variant(_))) => {
-                self.append_loan_path_to_str_from_interior(lp_base, out);
-                str::push_str(out, ".(tuple)");
-            }
-
             LpExtend(lp_base, _, LpDeref) => {
                 str::push_char(out, '*');
                 self.append_loan_path_to_str(lp_base, out);