---

yaml
---
r: 63762
b: refs/heads/snap-stage3
c: fda193d
h: refs/heads/master
v: v3

Author: michaelwoerister

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 366ca44cc8f79704f8781adb15e74d3c2a0e5572
+refs/heads/snap-stage3: fda193de247c592b7b5b0081df9cf95aeb7d3ce3
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -2620,7 +2620,7 @@ assert!(b != "world");
 
 The vector type constructor represents a homogeneous array of values of a given type.
 A vector has a fixed size.
-(Operations like `vec.push` operate solely on owned vectors.)
+(Operations like `vec::push` operate solely on owned vectors.)
 A vector type can be annotated with a _definite_ size,
 written with a trailing asterisk and integer literal, such as `[int * 10]`.
 Such a definite-sized vector type is a first-class type, since its size is known statically.

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -75,7 +75,7 @@ pub fn parse_config(args: ~[~str]) -> config {
          ];
 
     assert!(!args.is_empty());
-    let args_ = args.tail();
+    let args_ = vec::tail(args);
     let matches =
         &match getopts::getopts(args_, opts) {
           Ok(m) => m,
@@ -254,9 +254,17 @@ pub fn make_test(config: &config, testfile: &Path) -> test::TestDescAndFn {
 }
 
 pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
+
+    // Try to elide redundant long paths
+    fn shorten(path: &Path) -> ~str {
+        let filename = path.filename();
+        let dir = path.pop().filename();
+        fmt!("%s/%s", dir.get_or_default(~""), filename.get_or_default(~""))
+    }
+
     test::DynTestName(fmt!("[%s] %s",
                            mode_str(config.mode),
-                           testfile.to_str()))
+                           shorten(testfile)))
 }
 
 pub fn make_test_closure(config: &config, testfile: &Path) -> test::TestFn {

branches/snap-stage3/src/compiletest/runtest.rs

@@ -321,7 +321,8 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns =
-        props.error_patterns.slice(next_err_idx, props.error_patterns.len());
+        vec::slice(props.error_patterns, next_err_idx,
+                   props.error_patterns.len());
     if missing_patterns.len() == 1u {
         fatal_ProcRes(fmt!("error pattern '%s' not found!",
                            missing_patterns[0]), ProcRes);

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Jun 14
+" Last Change:  2013 Jun 14
 
 if version < 600
   syntax clear

branches/snap-stage3/src/libextra/arc.rs

@@ -19,7 +19,7 @@
  *
  * ~~~ {.rust}
  * extern mod std;
- * use std::arc;
+ * use extra::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
  * let shared_numbers=arc::ARC(numbers);
  *
@@ -517,6 +517,7 @@ mod tests {
 
     use arc::*;
 
+    use core::vec;
     use core::cell::Cell;
     use core::comm;
     use core::task;

branches/snap-stage3/src/libextra/base64.rs

@@ -36,8 +36,8 @@ impl<'self> ToBase64 for &'self [u8] {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod std;
-     * use std::base64::ToBase64;
+     * extern mod extra;
+     * use extra::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
@@ -99,8 +99,8 @@ impl<'self> ToBase64 for &'self str {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod std;
-     * use std::base64::ToBase64;
+     * extern mod extra;
+     * use extra::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
@@ -127,9 +127,9 @@ impl<'self> FromBase64 for &'self [u8] {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod std;
-     * use std::base64::ToBase64;
-     * use std::base64::FromBase64;
+     * extern mod extra;
+     * use extra::base64::ToBase64;
+     * use extra::base64::FromBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
@@ -207,9 +207,9 @@ impl<'self> FromBase64 for &'self str {
      * This converts a string literal to base64 and back.
      *
      * ~~~ {.rust}
-     * extern mod std;
-     * use std::base64::ToBase64;
-     * use std::base64::FromBase64;
+     * extern mod extra;
+     * use extra::base64::ToBase64;
+     * use extra::base64::FromBase64;
      * use core::str;
      *
      * fn main () {

branches/snap-stage3/src/libextra/c_vec.rs

@@ -159,7 +159,8 @@ mod tests {
 
             assert!(mem as int != 0);
 
-            c_vec_with_dtor(mem as *mut u8, n as uint, || free(mem))
+            return c_vec_with_dtor(mem as *mut u8, n as uint,
+                                   || unsafe { free(mem) });
         }
     }
 

branches/snap-stage3/src/libextra/crypto/sha2.rs

@@ -11,6 +11,7 @@
 use core::prelude::*;
 
 use core::uint;
+use core::vec;
 
 use digest::Digest;
 
@@ -117,7 +118,7 @@ impl Engine512 {
         }
 
         while in.len() - i >= 8 {
-            let w = to_u64(in.slice(i, i + 8));
+            let w = to_u64(vec::slice(in, i, i + 8));
             self.process_word(w);
             self.bit_counter.add_bytes(8);
             i += 8;
@@ -273,43 +274,43 @@ impl Engine512 {
     fn result_512(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, out.mut_slice(0, 8));
-        from_u64(self.H1, out.mut_slice(8, 16));
-        from_u64(self.H2, out.mut_slice(16, 24));
-        from_u64(self.H3, out.mut_slice(24, 32));
-        from_u64(self.H4, out.mut_slice(32, 40));
-        from_u64(self.H5, out.mut_slice(40, 48));
-        from_u64(self.H6, out.mut_slice(48, 56));
-        from_u64(self.H7, out.mut_slice(56, 64));
+        from_u64(self.H0, vec::mut_slice(out, 0, 8));
+        from_u64(self.H1, vec::mut_slice(out, 8, 16));
+        from_u64(self.H2, vec::mut_slice(out, 16, 24));
+        from_u64(self.H3, vec::mut_slice(out, 24, 32));
+        from_u64(self.H4, vec::mut_slice(out, 32, 40));
+        from_u64(self.H5, vec::mut_slice(out, 40, 48));
+        from_u64(self.H6, vec::mut_slice(out, 48, 56));
+        from_u64(self.H7, vec::mut_slice(out, 56, 64));
     }
 
     fn result_384(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, out.mut_slice(0, 8));
-        from_u64(self.H1, out.mut_slice(8, 16));
-        from_u64(self.H2, out.mut_slice(16, 24));
-        from_u64(self.H3, out.mut_slice(24, 32));
-        from_u64(self.H4, out.mut_slice(32, 40));
-        from_u64(self.H5, out.mut_slice(40, 48));
+        from_u64(self.H0, vec::mut_slice(out, 0, 8));
+        from_u64(self.H1, vec::mut_slice(out, 8, 16));
+        from_u64(self.H2, vec::mut_slice(out, 16, 24));
+        from_u64(self.H3, vec::mut_slice(out, 24, 32));
+        from_u64(self.H4, vec::mut_slice(out, 32, 40));
+        from_u64(self.H5, vec::mut_slice(out, 40, 48));
     }
 
     fn result_256(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, out.mut_slice(0, 8));
-        from_u64(self.H1, out.mut_slice(8, 16));
-        from_u64(self.H2, out.mut_slice(16, 24));
-        from_u64(self.H3, out.mut_slice(24, 32));
+        from_u64(self.H0, vec::mut_slice(out, 0, 8));
+        from_u64(self.H1, vec::mut_slice(out, 8, 16));
+        from_u64(self.H2, vec::mut_slice(out, 16, 24));
+        from_u64(self.H3, vec::mut_slice(out, 24, 32));
     }
 
     fn result_224(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, out.mut_slice(0, 8));
-        from_u64(self.H1, out.mut_slice(8, 16));
-        from_u64(self.H2, out.mut_slice(16, 24));
-        from_u32((self.H3 >> 32) as u32, out.mut_slice(24, 28));
+        from_u64(self.H0, vec::mut_slice(out, 0, 8));
+        from_u64(self.H1, vec::mut_slice(out, 8, 16));
+        from_u64(self.H2, vec::mut_slice(out, 16, 24));
+        from_u32((self.H3 >> 32) as u32, vec::mut_slice(out, 24, 28));
     }
 }
 
@@ -399,7 +400,7 @@ impl Engine256 {
         }
 
         while in.len() - i >= 4 {
-            let w = to_u32(in.slice(i, i + 4));
+            let w = to_u32(vec::slice(in, i, i + 4));
             self.process_word(w);
             self.length_bytes += 4;
             i += 4;
@@ -555,26 +556,26 @@ impl Engine256 {
     fn result_256(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u32(self.H0, out.mut_slice(0, 4));
-        from_u32(self.H1, out.mut_slice(4, 8));
-        from_u32(self.H2, out.mut_slice(8, 12));
-        from_u32(self.H3, out.mut_slice(12, 16));
-        from_u32(self.H4, out.mut_slice(16, 20));
-        from_u32(self.H5, out.mut_slice(20, 24));
-        from_u32(self.H6, out.mut_slice(24, 28));
-        from_u32(self.H7, out.mut_slice(28, 32));
+        from_u32(self.H0, vec::mut_slice(out, 0, 4));
+        from_u32(self.H1, vec::mut_slice(out, 4, 8));
+        from_u32(self.H2, vec::mut_slice(out, 8, 12));
+        from_u32(self.H3, vec::mut_slice(out, 12, 16));
+        from_u32(self.H4, vec::mut_slice(out, 16, 20));
+        from_u32(self.H5, vec::mut_slice(out, 20, 24));
+        from_u32(self.H6, vec::mut_slice(out, 24, 28));
+        from_u32(self.H7, vec::mut_slice(out, 28, 32));
     }
 
     fn result_224(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u32(self.H0, out.mut_slice(0, 4));
-        from_u32(self.H1, out.mut_slice(4, 8));
-        from_u32(self.H2, out.mut_slice(8, 12));
-        from_u32(self.H3, out.mut_slice(12, 16));
-        from_u32(self.H4, out.mut_slice(16, 20));
-        from_u32(self.H5, out.mut_slice(20, 24));
-        from_u32(self.H6, out.mut_slice(24, 28));
+        from_u32(self.H0, vec::mut_slice(out, 0, 4));
+        from_u32(self.H1, vec::mut_slice(out, 4, 8));
+        from_u32(self.H2, vec::mut_slice(out, 8, 12));
+        from_u32(self.H3, vec::mut_slice(out, 12, 16));
+        from_u32(self.H4, vec::mut_slice(out, 16, 20));
+        from_u32(self.H5, vec::mut_slice(out, 20, 24));
+        from_u32(self.H6, vec::mut_slice(out, 24, 28));
     }
 }
 

branches/snap-stage3/src/libextra/deque.rs

@@ -137,7 +137,7 @@ impl<T> Deque<T> {
     ///
     /// * n - The number of elements to reserve space for
     pub fn reserve(&mut self, n: uint) {
-        self.elts.reserve(n);
+        vec::reserve(&mut self.elts, n);
     }
 
     /// Reserve capacity for at least `n` elements in the given deque,
@@ -151,7 +151,7 @@ impl<T> Deque<T> {
     ///
     /// * n - The number of elements to reserve space for
     pub fn reserve_at_least(&mut self, n: uint) {
-        self.elts.reserve_at_least(n);
+        vec::reserve_at_least(&mut self.elts, n);
     }
 
     /// Front-to-back iterator.
@@ -256,6 +256,7 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
+    use core::vec::capacity;
     use core;
 
     #[test]
@@ -441,23 +442,23 @@ mod tests {
         let mut d = Deque::new();
         d.add_back(0u64);
         d.reserve(50);
-        assert_eq!(d.elts.capacity(), 50);
+        assert_eq!(capacity(&mut d.elts), 50);
         let mut d = Deque::new();
         d.add_back(0u32);
         d.reserve(50);
-        assert_eq!(d.elts.capacity(), 50);
+        assert_eq!(capacity(&mut d.elts), 50);
     }
 
     #[test]
     fn test_reserve_at_least() {
         let mut d = Deque::new();
         d.add_back(0u64);
         d.reserve_at_least(50);
-        assert_eq!(d.elts.capacity(), 64);
+        assert_eq!(capacity(&mut d.elts), 64);
         let mut d = Deque::new();
         d.add_back(0u32);
         d.reserve_at_least(50);
-        assert_eq!(d.elts.capacity(), 64);
+        assert_eq!(capacity(&mut d.elts), 64);
     }
 
     #[test]

branches/snap-stage3/src/libextra/dlist.rs

@@ -526,6 +526,8 @@ mod tests {
 
     use super::*;
 
+    use core::vec;
+
     #[test]
     fn test_dlist_concat() {
         let a = from_vec([1,2]);

branches/snap-stage3/src/libextra/ebml.rs

@@ -85,6 +85,7 @@ pub mod reader {
     use core::ptr::offset;
     use core::str;
     use core::unstable::intrinsics::bswap32;
+    use core::vec;
 
     // ebml reading
 
@@ -247,7 +248,7 @@ pub mod reader {
     }
 
     pub fn with_doc_data<T>(d: Doc, f: &fn(x: &[u8]) -> T) -> T {
-        f(d.data.slice(d.start, d.end))
+        f(vec::slice(*d.data, d.start, d.end))
     }
 
 

branches/snap-stage3/src/libextra/future.rs

@@ -17,7 +17,7 @@
  * ~~~ {.rust}
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
- * let mut delayed_fib = std::future::spawn (|| fib(5000) );
+ * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
  * make_a_sandwich();
  * println(fmt!("fib(5000) = %?", delayed_fib.get()))
  * ~~~

branches/snap-stage3/src/libextra/net_ip.rs

@@ -55,7 +55,7 @@ pub struct ParseAddrErr {
  *
  * # Arguments
  *
- * * ip - a `std::net::ip::IpAddr`
+ * * ip - a `extra::net::ip::IpAddr`
  */
 pub fn format_addr(ip: &IpAddr) -> ~str {
     match *ip {
@@ -80,7 +80,7 @@ pub fn format_addr(ip: &IpAddr) -> ~str {
  * Get the associated port
  *
  * # Arguments
- * * ip - a `std::net::ip::IpAddr`
+ * * ip - a `extra::net::ip::IpAddr`
  */
 pub fn get_port(ip: &IpAddr) -> uint {
     match *ip {