---

yaml
---
r: 65476
b: refs/heads/master
c: c582e3e
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 042618da7b70b30c910377860e7d5cb16001a6a6
+refs/heads/master: c582e3eb820feb0e7315054ec229e35c44a34719
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/tutorial-ffi.md

@@ -188,7 +188,7 @@ impl<T: Owned> Drop for Unique<T> {
         unsafe {
             let mut x = intrinsics::init(); // dummy value to swap in
             // moving the object out is needed to call the destructor
-            ptr::replace_ptr(self.ptr, x);
+            util::replace_ptr(self.ptr, x);
             free(self.ptr as *c_void)
         }
     }

trunk/src/libextra/rc.rs

@@ -28,6 +28,7 @@ use core::libc::{c_void, size_t, malloc, free};
 use core::ptr;
 use core::sys;
 use core::unstable::intrinsics;
+use core::util;
 
 struct RcBox<T> {
     value: T,
@@ -72,7 +73,7 @@ impl<T> Drop for Rc<T> {
         unsafe {
             (*self.ptr).count -= 1;
             if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, intrinsics::uninit());
+                util::replace_ptr(self.ptr, intrinsics::uninit());
                 free(self.ptr as *c_void)
             }
         }
@@ -222,7 +223,7 @@ impl<T> Drop for RcMut<T> {
         unsafe {
             (*self.ptr).count -= 1;
             if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, uninit());
+                util::replace_ptr(self.ptr, uninit());
                 free(self.ptr as *c_void)
             }
         }

trunk/src/librustc/back/passes.rs

@@ -134,7 +134,6 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
     passes.push(~"correlated-propagation");
     passes.push(~"dse");
 
-    passes.push(~"bb-vectorize");
     passes.push(~"instcombine");
     passes.push(~"early-cse");
 

trunk/src/librustc/middle/privacy.rs

@@ -200,7 +200,7 @@ pub fn check_crate(tcx: ty::ctxt,
         f = |item_id| {
             match tcx.items.find(&item_id) {
                 Some(&node_item(item, _)) => item.vis != public,
-                Some(&node_foreign_item(_, _, vis, _)) => vis != public,
+                Some(&node_foreign_item(*)) => false,
                 Some(&node_method(method, impl_did, _)) => {
                     match method.vis {
                         private => true,

trunk/src/librustc/middle/resolve.rs

@@ -3079,7 +3079,7 @@ pub impl Resolver {
                 self.session.span_err(imports[index].span, "unresolved import");
             } else {
                 let err = fmt!("unresolved import (maybe you meant `%s::*`?)",
-                               sn.slice(0, sn.len() - 1)); // -1 to adjust for semicolon
+                               sn.slice(0, sn.len()));
                 self.session.span_err(imports[index].span, err);
             }
         }

trunk/src/libstd/ptr.rs

@@ -15,7 +15,6 @@ use cast;
 #[cfg(stage0)] use libc::{c_void, size_t};
 use option::{Option, Some, None};
 use sys;
-use unstable::intrinsics;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 use uint;
@@ -72,11 +71,11 @@ pub unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint {
 
 /// Create an unsafe null pointer
 #[inline(always)]
-pub fn null<T>() -> *T { 0 as *T }
+pub fn null<T>() -> *T { unsafe { cast::transmute(0u) } }
 
 /// Create an unsafe mutable null pointer
 #[inline(always)]
-pub fn mut_null<T>() -> *mut T { 0 as *mut T }
+pub fn mut_null<T>() -> *mut T { unsafe { cast::transmute(0u) } }
 
 /// Returns true if the pointer is equal to the null pointer.
 #[inline(always)]
@@ -208,57 +207,47 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
 }
 
 /**
- * Swap the values at two mutable locations of the same type, without
- * deinitialising or copying either one.
- */
-#[inline]
-pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
-    // Give ourselves some scratch space to work with
-    let mut tmp: T = intrinsics::uninit();
-    let t: *mut T = &mut tmp;
-
-    // Perform the swap
-    copy_memory(t, x, 1);
-    copy_memory(x, y, 1);
-    copy_memory(y, t, 1);
-
-    // y and t now point to the same thing, but we need to completely forget `tmp`
-    // because it's no longer relevant.
-    cast::forget(tmp);
-}
-
-/**
- * Replace the value at a mutable location with a new one, returning the old
- * value, without deinitialising or copying either one.
- */
-#[inline(always)]
-pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
-    swap_ptr(dest, &mut src);
-    src
-}
-
-/// Transform a region pointer - &T - to an unsafe pointer - *T.
+  Transform a region pointer - &T - to an unsafe pointer - *T.
+  This is safe, but is implemented with an unsafe block due to
+  transmute.
+*/
 #[inline(always)]
 pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
-    thing as *T
+    unsafe { cast::transmute(thing) }
 }
 
-/// Transform a const region pointer - &const T - to a const unsafe pointer - *const T.
+/**
+  Transform a const region pointer - &const T - to a const unsafe pointer -
+  *const T. This is safe, but is implemented with an unsafe block due to
+  transmute.
+*/
 #[inline(always)]
 pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
-    thing as *const T
+    unsafe { cast::transmute(thing) }
 }
 
-/// Transform a mutable region pointer - &mut T - to a mutable unsafe pointer - *mut T.
+/**
+  Transform a mutable region pointer - &mut T - to a mutable unsafe pointer -
+  *mut T. This is safe, but is implemented with an unsafe block due to
+  transmute.
+*/
 #[inline(always)]
 pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
-    thing as *mut T
+    unsafe { cast::transmute(thing) }
 }
 
-/// Cast a region pointer - &T - to a uint.
+/**
+  Cast a region pointer - &T - to a uint.
+  This is safe, but is implemented with an unsafe block due to
+  transmute.
+
+  (I couldn't think of a cutesy name for this one.)
+*/
 #[inline(always)]
 pub fn to_uint<T>(thing: &T) -> uint {
-    thing as *T as uint
+    unsafe {
+        cast::transmute(thing)
+    }
 }
 
 /// Determine if two borrowed pointers point to the same thing.
@@ -384,30 +373,50 @@ impl<T> Ptr<T> for *mut T {
 impl<T> Eq for *const T {
     #[inline(always)]
     fn eq(&self, other: &*const T) -> bool {
-        (*self as uint) == (*other as uint)
+        unsafe {
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
+            return a == b;
+        }
     }
     #[inline(always)]
-    fn ne(&self, other: &*const T) -> bool { !self.eq(other) }
+    fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) }
 }
 
 // Comparison for pointers
 #[cfg(not(test))]
 impl<T> Ord for *const T {
     #[inline(always)]
     fn lt(&self, other: &*const T) -> bool {
-        (*self as uint) < (*other as uint)
+        unsafe {
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
+            return a < b;
+        }
     }
     #[inline(always)]
     fn le(&self, other: &*const T) -> bool {
-        (*self as uint) <= (*other as uint)
+        unsafe {
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
+            return a <= b;
+        }
     }
     #[inline(always)]
     fn ge(&self, other: &*const T) -> bool {
-        (*self as uint) >= (*other as uint)
+        unsafe {
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
+            return a >= b;
+        }
     }
     #[inline(always)]
     fn gt(&self, other: &*const T) -> bool {
-        (*self as uint) > (*other as uint)
+        unsafe {
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
+            return a > b;
+        }
     }
 }
 
@@ -416,11 +425,11 @@ impl<T> Ord for *const T {
 impl<'self,T:Eq> Eq for &'self T {
     #[inline(always)]
     fn eq(&self, other: & &'self T) -> bool {
-        *(*self) == *(*other)
+        return *(*self) == *(*other);
     }
     #[inline(always)]
     fn ne(&self, other: & &'self T) -> bool {
-        *(*self) != *(*other)
+        return *(*self) != *(*other);
     }
 }
 

trunk/src/libstd/util.rs

@@ -64,6 +64,26 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
     }
 }
 
+/**
+ * Swap the values at two mutable locations of the same type, without
+ * deinitialising or copying either one.
+ */
+#[inline]
+pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
+    // Give ourselves some scratch space to work with
+    let mut tmp: T = intrinsics::uninit();
+    let t: *mut T = &mut tmp;
+
+    // Perform the swap
+    ptr::copy_memory(t, x, 1);
+    ptr::copy_memory(x, y, 1);
+    ptr::copy_memory(y, t, 1);
+
+    // y and t now point to the same thing, but we need to completely forget `tmp`
+    // because it's no longer relevant.
+    cast::forget(tmp);
+}
+
 /**
  * Replace the value at a mutable location with a new one, returning the old
  * value, without deinitialising or copying either one.
@@ -74,6 +94,16 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
     src
 }
 
+/**
+ * Replace the value at a mutable location with a new one, returning the old
+ * value, without deinitialising or copying either one.
+ */
+#[inline(always)]
+pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
+    swap_ptr(dest, ptr::to_mut_unsafe_ptr(&mut src));
+    src
+}
+
 /// A non-copyable dummy type.
 pub struct NonCopyable {
     priv i: (),

trunk/src/libstd/vec.rs

@@ -506,7 +506,7 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
         let vp = raw::to_mut_ptr(*v);
         let vp = ptr::mut_offset(vp, next_ln - 1);
 
-        ptr::replace_ptr(vp, work_elt)
+        util::replace_ptr(vp, work_elt)
     }
 }
 
@@ -570,7 +570,7 @@ pub fn consume<T>(mut v: ~[T], f: &fn(uint, v: T)) {
                 // elements during unwinding
                 let x = intrinsics::init();
                 let p = ptr::mut_offset(p, i);
-                f(i, ptr::replace_ptr(p, x));
+                f(i, util::replace_ptr(p, x));
             }
         }
 
@@ -597,7 +597,7 @@ pub fn consume_reverse<T>(mut v: ~[T], f: &fn(uint, v: T)) {
                 // elements during unwinding
                 let x = intrinsics::init();
                 let p = ptr::mut_offset(p, i);
-                f(i, ptr::replace_ptr(p, x));
+                f(i, util::replace_ptr(p, x));
             }
         }
 
@@ -613,7 +613,7 @@ pub fn pop<T>(v: &mut ~[T]) -> T {
     }
     let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
-        let val = ptr::replace_ptr(valptr, intrinsics::init());
+        let val = util::replace_ptr(valptr, intrinsics::init());
         raw::set_len(v, ln - 1u);
         val
     }
@@ -707,8 +707,8 @@ pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
     unsafe {
         do as_mut_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
-                let x = ptr::replace_ptr(ptr::mut_offset(p, i),
-                                         intrinsics::uninit());
+                let x = util::replace_ptr(ptr::mut_offset(p, i),
+                                          intrinsics::uninit());
                 push(&mut *v, x);
             }
         }
@@ -723,7 +723,7 @@ pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
-                ptr::replace_ptr(ptr::mut_offset(p, i), intrinsics::uninit());
+                util::replace_ptr(ptr::mut_offset(p, i), intrinsics::uninit());
             }
         }
     }
@@ -747,14 +747,14 @@ pub fn dedup<T:Eq>(v: &mut ~[T]) {
                 // last_written < next_to_read < ln
                 if *ptr::mut_offset(p, next_to_read) ==
                     *ptr::mut_offset(p, last_written) {
-                    ptr::replace_ptr(ptr::mut_offset(p, next_to_read),
-                                     intrinsics::uninit());
+                    util::replace_ptr(ptr::mut_offset(p, next_to_read),
+                                      intrinsics::uninit());
                 } else {
                     last_written += 1;
                     // last_written <= next_to_read < ln
                     if next_to_read != last_written {
-                        ptr::swap_ptr(ptr::mut_offset(p, last_written),
-                                      ptr::mut_offset(p, next_to_read));
+                        util::swap_ptr(ptr::mut_offset(p, last_written),
+                                       ptr::mut_offset(p, next_to_read));
                     }
                 }
                 // last_written <= next_to_read < ln
@@ -1398,7 +1398,7 @@ pub fn swap<T>(v: &mut [T], a: uint, b: uint) {
         // them to their raw pointers to do the swap
         let pa: *mut T = ptr::to_mut_unsafe_ptr(&mut v[a]);
         let pb: *mut T = ptr::to_mut_unsafe_ptr(&mut v[b]);
-        ptr::swap_ptr(pa, pb);
+        util::swap_ptr(pa, pb);
     }
 }
 

trunk/src/test/compile-fail/unresolved-extern-mod-suggestion.rs

@@ -0,0 +1,14 @@
+// Copyright 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.
+
+extern mod extra;
+use extra; //~ ERROR unresolved import (maybe you meant `extra::*`?)
+
+fn main() {}