---

yaml
---
r: 140662
b: refs/heads/try2
c: 1393c3a
h: refs/heads/master
v: v3

Author: dotdash

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f04eb37c7ea19bbd2cff12d15816873e0a46fc86
+refs/heads/try2: 1393c3a3f438c896083405dca501c8cf05767c65
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-ffi.md

@@ -157,7 +157,7 @@ pub struct Unique<T> {
     priv ptr: *mut T
 }
 
-pub impl<T: Owned> Unique<T> {
+pub impl<'self, T: Owned> Unique<T> {
     fn new(value: T) -> Unique<T> {
         unsafe {
             let ptr = malloc(core::sys::size_of::<T>() as size_t) as *mut T;
@@ -168,14 +168,14 @@ pub impl<T: Owned> Unique<T> {
         }
     }
 
-    // the 'r lifetime results in the same semantics as `&*x` with ~T
-    fn borrow<'r>(&'r self) -> &'r T {
-        unsafe { cast::copy_lifetime(self, &*self.ptr) }
+    // the 'self lifetime results in the same semantics as `&*x` with ~T
+    fn borrow(&self) -> &'self T {
+        unsafe { cast::transmute(self.ptr) }
     }
 
-    // the 'r lifetime results in the same semantics as `&mut *x` with ~T
-    fn borrow_mut<'r>(&'r mut self) -> &'r mut T {
-        unsafe { cast::copy_mut_lifetime(self, &mut *self.ptr) }
+    // the 'self lifetime results in the same semantics as `&mut *x` with ~T
+    fn borrow_mut(&mut self) -> &'self mut T {
+        unsafe { cast::transmute(self.ptr) }
     }
 }
 

branches/try2/src/compiletest/runtest.rs

@@ -764,7 +764,7 @@ fn _arm_exec_compiled_test(config: config, props: TestProps,
     logv(config, fmt!("executing (%s) %s", config.target, cmdline));
 
     // adb shell dose not forward stdout and stderr of internal result
-    // to stdout and stderr separately but to stdout only
+    // to stdout and stderr seperately but to stdout only
     let mut newargs_out = ~[];
     let mut newargs_err = ~[];
     let subargs = args.args;

branches/try2/src/libcore/at_vec.rs

@@ -52,7 +52,7 @@ pub fn capacity<T>(v: @[T]) -> uint {
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -70,7 +70,7 @@ pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] {
  *
  * # Arguments
  *
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -87,7 +87,7 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> @[A] {
  * # Arguments
  *
  * * size - An option, maybe containing initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/try2/src/libcore/cast.rs

@@ -24,20 +24,6 @@ pub mod rusti {
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(not(stage0))]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = unstable::intrinsics::uninit();
-    {
-        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);
-    }
-    dest
-}
-
-#[cfg(stage0)]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = unstable::intrinsics::init();
     {
@@ -122,12 +108,6 @@ pub unsafe fn copy_lifetime<'a,S,T>(_ptr: &'a S, ptr: &T) -> &'a T {
     transmute_region(ptr)
 }
 
-/// Transforms lifetime of the second pointer to match the first.
-#[inline(always)]
-pub unsafe fn copy_mut_lifetime<'a,S,T>(_ptr: &'a mut S, ptr: &mut T) -> &'a mut T {
-    transmute_mut_region(ptr)
-}
-
 /// Transforms lifetime of the second pointer to match the first.
 #[inline(always)]
 pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {

branches/try2/src/libcore/core.rc

@@ -60,6 +60,7 @@ they contained the following prologue:
 // Don't link to core. We are core.
 #[no_core];
 
+#[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
 

branches/try2/src/libcore/iter.rs

@@ -17,7 +17,8 @@ breaking out of iteration. The adaptors in the module work with any such iterato
 tied to specific traits. For example:
 
 ~~~~
-println(iter::to_vec(|f| uint::range(0, 20, f)).to_str());
+use core::iter::iter_to_vec;
+println(iter_to_vec(|f| uint::range(0, 20, f)).to_str());
 ~~~~
 
 An external iterator object implementing the interface in the `iterator` module can be used as an
@@ -54,12 +55,12 @@ pub trait Times {
  *
  * ~~~
  * let xs = ~[1, 2, 3];
- * let ys = do iter::to_vec |f| { xs.each(|x| f(*x)) };
+ * let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
  * assert_eq!(xs, ys);
  * ~~~
  */
 #[inline(always)]
-pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
+pub fn iter_to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
     let mut v = ~[];
     for iter |x| { v.push(x) }
     v
@@ -184,9 +185,9 @@ mod tests {
     use prelude::*;
 
     #[test]
-    fn test_to_vec() {
+    fn test_iter_to_vec() {
         let xs = ~[1, 2, 3];
-        let ys = do to_vec |f| { xs.each(|x| f(*x)) };
+        let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
         assert_eq!(xs, ys);
     }
 

branches/try2/src/libcore/iterator.rs

@@ -378,7 +378,7 @@ mod tests {
     #[test]
     fn test_counter_to_vec() {
         let mut it = Counter::new(0, 5).take(10);
-        let xs = iter::to_vec(|f| it.advance(f));
+        let xs = iter::iter_to_vec(|f| it.advance(f));
         assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
     }
 

branches/try2/src/libcore/rt/io/extensions.rs

@@ -11,7 +11,7 @@
 //! Utility mixins that apply to all Readers and Writers
 
 // XXX: Not sure how this should be structured
-// XXX: Iteration should probably be considered separately
+// XXX: Iteration should probably be considered seperately
 
 pub trait ReaderUtil {
 

branches/try2/src/libcore/task/local_data_priv.rs

@@ -133,7 +133,7 @@ unsafe fn get_newsched_local_map(local: *mut LocalStorage) -> TaskLocalMap {
 
 unsafe fn key_to_key_value<T: 'static>(key: LocalDataKey<T>) -> *libc::c_void {
     // Keys are closures, which are (fnptr,envptr) pairs. Use fnptr.
-    // Use reinterpret_cast -- transmute would leak (forget) the closure.
+    // Use reintepret_cast -- transmute would leak (forget) the closure.
     let pair: (*libc::c_void, *libc::c_void) = cast::transmute_copy(&key);
     pair.first()
 }

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -44,9 +44,6 @@ pub extern "rust-intrinsic" {
 
     pub fn init<T>() -> T;
 
-    #[cfg(not(stage0))]
-    pub unsafe fn uninit<T>() -> T;
-
     pub fn forget<T>(_: T) -> ();
 
     pub fn needs_drop<T>() -> bool;

branches/try2/src/libcore/vec.rs

@@ -219,7 +219,7 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> ~[A] {
  * # Arguments
  *
  * * size - An option, maybe containing initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -584,29 +584,14 @@ pub fn consume_reverse<T>(mut v: ~[T], f: &fn(uint, v: T)) {
 }
 
 /// Remove the last element from a vector and return it
-#[cfg(not(stage0))]
-pub fn pop<T>(v: &mut ~[T]) -> T {
-    let ln = v.len();
-    if ln == 0 {
-        fail!(~"sorry, cannot vec::pop an empty vector")
-    }
-    let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
-    unsafe {
-        let mut val = intrinsics::uninit();
-        val <-> *valptr;
-        raw::set_len(v, ln - 1u);
-        val
-    }
-}
-
-#[cfg(stage0)]
 pub fn pop<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
     if ln == 0 {
         fail!(~"sorry, cannot vec::pop an empty vector")
     }
     let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
+        // FIXME #4204: Should be uninit() - we don't need this zeroed
         let mut val = intrinsics::init();
         val <-> *valptr;
         raw::set_len(v, ln - 1u);
@@ -675,30 +660,13 @@ pub fn push_all<T:Copy>(v: &mut ~[T], rhs: &const [T]) {
 }
 
 #[inline(always)]
-#[cfg(not(stage0))]
-pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
-    let new_len = v.len() + rhs.len();
-    reserve(&mut *v, new_len);
-    unsafe {
-        do as_mut_buf(rhs) |p, len| {
-            for uint::range(0, len) |i| {
-                let mut x = intrinsics::uninit();
-                x <-> *ptr::mut_offset(p, i);
-                push(&mut *v, x);
-            }
-        }
-        raw::set_len(&mut rhs, 0);
-    }
-}
-
-#[inline(always)]
-#[cfg(stage0)]
 pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
     let new_len = v.len() + rhs.len();
     reserve(&mut *v, new_len);
     unsafe {
         do as_mut_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
+                // FIXME #4204 Should be uninit() - don't need to zero
                 let mut x = intrinsics::init();
                 x <-> *ptr::mut_offset(p, i);
                 push(&mut *v, x);
@@ -709,29 +677,13 @@ pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
 }
 
 /// Shorten a vector, dropping excess elements.
-#[cfg(not(stage0))]
-pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
-    do as_mut_buf(*v) |p, oldlen| {
-        assert!(newlen <= oldlen);
-        unsafe {
-            // This loop is optimized out for non-drop types.
-            for uint::range(newlen, oldlen) |i| {
-                let mut dropped = intrinsics::uninit();
-                dropped <-> *ptr::mut_offset(p, i);
-            }
-        }
-    }
-    unsafe { raw::set_len(&mut *v, newlen); }
-}
-
-/// Shorten a vector, dropping excess elements.
-#[cfg(stage0)]
 pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
     do as_mut_buf(*v) |p, oldlen| {
         assert!(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
+                // FIXME #4204 Should be uninit() - don't need to zero
                 let mut dropped = intrinsics::init();
                 dropped <-> *ptr::mut_offset(p, i);
             }
@@ -744,45 +696,6 @@ pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
  * Remove consecutive repeated elements from a vector; if the vector is
  * sorted, this removes all duplicates.
  */
-#[cfg(not(stage0))]
-pub fn dedup<T:Eq>(v: &mut ~[T]) {
-    unsafe {
-        if v.len() < 1 { return; }
-        let mut last_written = 0, next_to_read = 1;
-        do as_const_buf(*v) |p, ln| {
-            // We have a mutable reference to v, so we can make arbitrary
-            // changes. (cf. push and pop)
-            let p = p as *mut T;
-            // last_written < next_to_read <= ln
-            while next_to_read < ln {
-                // last_written < next_to_read < ln
-                if *ptr::mut_offset(p, next_to_read) ==
-                    *ptr::mut_offset(p, last_written) {
-                    let mut dropped = intrinsics::uninit();
-                    dropped <-> *ptr::mut_offset(p, next_to_read);
-                } else {
-                    last_written += 1;
-                    // last_written <= next_to_read < ln
-                    if next_to_read != last_written {
-                        *ptr::mut_offset(p, last_written) <->
-                            *ptr::mut_offset(p, next_to_read);
-                    }
-                }
-                // last_written <= next_to_read < ln
-                next_to_read += 1;
-                // last_written < next_to_read <= ln
-            }
-        }
-        // last_written < next_to_read == ln
-        raw::set_len(v, last_written + 1);
-    }
-}
-
-/**
- * Remove consecutive repeated elements from a vector; if the vector is
- * sorted, this removes all duplicates.
- */
-#[cfg(stage0)]
 pub fn dedup<T:Eq>(v: &mut ~[T]) {
     unsafe {
         if v.len() < 1 { return; }
@@ -796,6 +709,8 @@ 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) {
+                    // FIXME #4204 Should be uninit() - don't need to
+                    // zero
                     let mut dropped = intrinsics::init();
                     dropped <-> *ptr::mut_offset(p, next_to_read);
                 } else {

branches/try2/src/librustc/back/link.rs

@@ -698,8 +698,8 @@ pub fn exported_name(sess: Session,
                      vers: &str) -> ~str {
     return mangle(sess,
             vec::append_one(
-            vec::append_one(path, path_name(sess.ident_of(hash.to_owned()))),
-            path_name(sess.ident_of(vers.to_owned()))));
+            vec::append_one(path, path_name(sess.ident_of(hash))),
+            path_name(sess.ident_of(vers))));
 }
 
 pub fn mangle_exported_name(ccx: @CrateContext,
@@ -717,14 +717,14 @@ pub fn mangle_internal_name_by_type_only(ccx: @CrateContext,
     let s = ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
     return mangle(ccx.sess,
-        ~[path_name(ccx.sess.ident_of(name.to_owned())),
+        ~[path_name(ccx.sess.ident_of(name)),
           path_name(ccx.sess.ident_of(s)),
-          path_name(ccx.sess.ident_of(hash.to_owned()))]);
+          path_name(ccx.sess.ident_of(hash))]);
 }
 
 pub fn mangle_internal_name_by_path_and_seq(ccx: @CrateContext,
                                             path: path,
-                                            flav: ~str) -> ~str {
+                                            flav: &str) -> ~str {
     return mangle(ccx.sess,
                   vec::append_one(path, path_name((ccx.names)(flav))));
 }
@@ -733,7 +733,7 @@ pub fn mangle_internal_name_by_path(ccx: @CrateContext, path: path) -> ~str {
     return mangle(ccx.sess, path);
 }
 
-pub fn mangle_internal_name_by_seq(ccx: @CrateContext, flav: ~str) -> ~str {
+pub fn mangle_internal_name_by_seq(ccx: @CrateContext, flav: &str) -> ~str {
     return fmt!("%s_%u", flav, (ccx.names)(flav).repr);
 }