---

yaml
---
r: 150909
b: refs/heads/try2
c: 30ff17f
h: refs/heads/master
i:
  150907: 8b8b736
v: v3

Author: alexcrichton

[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: b75683cadf6c4c55360202cd6a0106be80532451
+refs/heads/try2: 30ff17f809869dec37d7b501fb532dc88fd47832
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/README.md

@@ -25,7 +25,6 @@ documentation.
     * `perl` 5.0 or later
     * GNU `make` 3.81 or later
     * `curl`
-    * `git`
 2. Download and build Rust:
 
     You can either download a [tarball] or build directly from the [repo].

branches/try2/configure

@@ -921,10 +921,6 @@ do
         LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
-        # LLVM says it needs a "new" clang/gcc, but we seem to get by ok with
-        # older versions on the bots. Get by for a little longer by asking it to
-        # not do version detection
-        LLVM_OPTS="$LLVM_OPTS --disable-compiler-version-checks"
 
         # Use win32 native thread/lock apis instead of pthread wrapper.
         # (llvm's configure tries to find pthread first, so we have to disable it explicitly.)

branches/try2/mk/tests.mk

@@ -568,7 +568,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         --host $(3)                                       \
         --adb-path=$(CFG_ADB)                          \
         --adb-test-dir=$(CFG_ADB_TEST_DIR)                  \
-        --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \
+        --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(2))" \
         --target-rustcflags "$(RUSTC_FLAGS_$(2)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(2))" \
         $$(CTEST_TESTARGS)
 

branches/try2/src/compiletest/runtest.rs

@@ -33,6 +33,7 @@ use std::os;
 use std::str;
 use std::strbuf::StrBuf;
 use std::task;
+use std::slice;
 use test::MetricMap;
 
 pub fn run(config: config, testfile: ~str) {
@@ -508,7 +509,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          proc_res: &ProcRes) {
 
     // true if we found the error in question
-    let mut found_flags = Vec::from_elem(
+    let mut found_flags = slice::from_elem(
         expected_errors.len(), false);
 
     if proc_res.status.success() {
@@ -553,13 +554,13 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     for line in proc_res.stderr.lines() {
         let mut was_expected = false;
         for (i, ee) in expected_errors.iter().enumerate() {
-            if !*found_flags.get(i) {
+            if !found_flags[i] {
                 debug!("prefix={} ee.kind={} ee.msg={} line={}",
                        *prefixes.get(i), ee.kind, ee.msg, line);
                 if prefix_matches(line, *prefixes.get(i)) &&
                     line.contains(ee.kind) &&
                     line.contains(ee.msg) {
-                    *found_flags.get_mut(i) = true;
+                    found_flags[i] = true;
                     was_expected = true;
                     break;
                 }

branches/try2/src/doc/guide-pointers.md

@@ -430,9 +430,8 @@ great detail, so if you want the full details, check that out.
 # Returning Pointers
 
 We've talked a lot about functions that accept various kinds of pointers, but
-what about returning them? In general, it is better to let the caller decide
-how to use a function's output, instead of assuming a certain type of pointer
-is best.
+what about returning them? Here's the rule of thumb: only return a unique or
+managed pointer if you were given one in the first place.
 
 What does that mean? Don't do this:
 

branches/try2/src/doc/guide-tasks.md

@@ -255,9 +255,10 @@ might look like the example below.
 
 ~~~
 # use std::task::spawn;
+# use std::slice;
 
 // Create a vector of ports, one for each child task
-let rxs = Vec::from_fn(3, |init_val| {
+let rxs = slice::from_fn(3, |init_val| {
     let (tx, rx) = channel();
     spawn(proc() {
         tx.send(some_expensive_computation(init_val));
@@ -303,6 +304,7 @@ be distributed on the available cores.
 
 ~~~
 # extern crate sync;
+# use std::slice;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for num in range(start*100000, (start+1)*100000) {
@@ -312,7 +314,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = Vec::from_fn(1000, |ind| sync::Future::spawn( proc() { partial_sum(ind) }));
+    let mut futures = slice::from_fn(1000, |ind| sync::Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.mut_iter()  {
@@ -340,24 +342,25 @@ a single large vector of floats. Each task needs the full vector to perform its
 extern crate rand;
 extern crate sync;
 
+use std::slice;
 use sync::Arc;
 
-fn pnorm(nums: &[f64], p: uint) -> f64 {
+fn pnorm(nums: &~[f64], p: uint) -> f64 {
     nums.iter().fold(0.0, |a,b| a+(*b).powf(&(p as f64)) ).powf(&(1.0 / (p as f64)))
 }
 
 fn main() {
-    let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
+    let numbers = slice::from_fn(1000000, |_| rand::random::<f64>());
     let numbers_arc = Arc::new(numbers);
 
     for num in range(1u, 10) {
         let (tx, rx) = channel();
         tx.send(numbers_arc.clone());
 
         spawn(proc() {
-            let local_arc : Arc<Vec<f64>> = rx.recv();
+            let local_arc : Arc<~[f64]> = rx.recv();
             let task_numbers = &*local_arc;
-            println!("{}-norm = {}", num, pnorm(task_numbers.as_slice(), num));
+            println!("{}-norm = {}", num, pnorm(task_numbers, num));
         });
     }
 }
@@ -371,8 +374,9 @@ created by the line
 # extern crate sync;
 # extern crate rand;
 # use sync::Arc;
+# use std::slice;
 # fn main() {
-# let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
+# let numbers = slice::from_fn(1000000, |_| rand::random::<f64>());
 let numbers_arc=Arc::new(numbers);
 # }
 ~~~
@@ -383,8 +387,9 @@ and a clone of it is sent to each task
 # extern crate sync;
 # extern crate rand;
 # use sync::Arc;
+# use std::slice;
 # fn main() {
-# let numbers=Vec::from_fn(1000000, |_| rand::random::<f64>());
+# let numbers=slice::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc = Arc::new(numbers);
 # let (tx, rx) = channel();
 tx.send(numbers_arc.clone());
@@ -399,12 +404,13 @@ Each task recovers the underlying data by
 # extern crate sync;
 # extern crate rand;
 # use sync::Arc;
+# use std::slice;
 # fn main() {
-# let numbers=Vec::from_fn(1000000, |_| rand::random::<f64>());
+# let numbers=slice::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc=Arc::new(numbers);
 # let (tx, rx) = channel();
 # tx.send(numbers_arc.clone());
-# let local_arc : Arc<Vec<f64>> = rx.recv();
+# let local_arc : Arc<~[f64]> = rx.recv();
 let task_numbers = &*local_arc;
 # }
 ~~~

branches/try2/src/doc/tutorial.md

@@ -1582,12 +1582,12 @@ the elements are mutable if the vector is mutable.
 use std::strbuf::StrBuf;
 
 // A dynamically sized vector (unique vector)
-let mut numbers = vec![1, 2, 3];
+let mut numbers = ~[1, 2, 3];
 numbers.push(4);
 numbers.push(5);
 
 // The type of a unique vector is written as `~[int]`
-let more_numbers: ~[int] = numbers.move_iter().collect();
+let more_numbers: ~[int] = numbers;
 
 // The original `numbers` value can no longer be used, due to move semantics.
 
@@ -1955,8 +1955,8 @@ vector consisting of the result of applying `function` to each element
 of `vector`:
 
 ~~~~
-fn map<T, U>(vector: &[T], function: |v: &T| -> U) -> Vec<U> {
-    let mut accumulator = Vec::new();
+fn map<T, U>(vector: &[T], function: |v: &T| -> U) -> ~[U] {
+    let mut accumulator = ~[];
     for element in vector.iter() {
         accumulator.push(function(element));
     }

branches/try2/src/etc/vim/indent/rust.vim

@@ -105,7 +105,6 @@ function GetRustIndent(lnum)
 	if prevline[len(prevline) - 1] == ","
 				\ && s:get_line_trimmed(a:lnum) !~ "^\\s*[\\[\\]{}]"
 				\ && prevline !~ "^\\s*fn\\s"
-				\ && prevline !~ "\\([^\\(\\)]\+,$"
 		" Oh ho! The previous line ended in a comma! I bet cindent will try to
 		" take this too far... For now, let's normally use the previous line's
 		" indent.
@@ -120,16 +119,6 @@ function GetRustIndent(lnum)
 		" fn foo(baz: Baz,
 		"        baz: Baz) // <-- cindent gets this right by itself
 		"
-		" Another case is similar to the previous, except calling a function
-		" instead of defining it, or any conditional expression that leaves
-		" an open paren:
-		"
-		" foo(baz,
-		"     baz);
-		"
-		" if baz && (foo ||
-		"            bar) {
-		"
 		" There are probably other cases where we don't want to do this as
 		" well. Add them as needed.
 		return GetRustIndent(a:lnum - 1)

branches/try2/src/libcollections/bitv.rs

@@ -97,12 +97,12 @@ impl SmallBitv {
     pub fn set_all(&mut self) { self.bits = !0; }
 
     #[inline]
-    pub fn all(&self, nbits: uint) -> bool {
+    pub fn is_true(&self, nbits: uint) -> bool {
         small_mask(nbits) & !self.bits == 0
     }
 
     #[inline]
-    pub fn none(&self, nbits: uint) -> bool {
+    pub fn is_false(&self, nbits: uint) -> bool {
         small_mask(nbits) & self.bits == 0
     }
 
@@ -412,10 +412,13 @@ impl Bitv {
 
     /// Returns `true` if all bits are 1
     #[inline]
-    pub fn all(&self) -> bool {
+    pub fn is_true(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.all(self.nbits),
-        _ => self.iter().all(|x| x)
+        Small(ref b) => b.is_true(self.nbits),
+        _ => {
+          for i in self.iter() { if !i { return false; } }
+          true
+        }
       }
     }
 
@@ -430,19 +433,16 @@ impl Bitv {
     }
 
     /// Returns `true` if all bits are 0
-    pub fn none(&self) -> bool {
+    pub fn is_false(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.none(self.nbits),
-        _ => self.iter().all(|x| !x)
+        Small(ref b) => b.is_false(self.nbits),
+        Big(_) => {
+          for i in self.iter() { if i { return false; } }
+          true
+        }
       }
     }
 
-    #[inline]
-    /// Returns `true` if any bit is 1
-    pub fn any(&self) -> bool {
-        !self.none()
-    }
-
     pub fn init_to_vec(&self, i: uint) -> uint {
       return if self.get(i) { 1 } else { 0 };
     }
@@ -1551,51 +1551,6 @@ mod tests {
         assert!(b.contains(&1000));
     }
 
-    #[test]
-    fn test_small_bitv_tests() {
-        let v = from_bytes([0]);
-        assert!(!v.all());
-        assert!(!v.any());
-        assert!(v.none());
-
-        let v = from_bytes([0b00010100]);
-        assert!(!v.all());
-        assert!(v.any());
-        assert!(!v.none());
-
-        let v = from_bytes([0xFF]);
-        assert!(v.all());
-        assert!(v.any());
-        assert!(!v.none());
-    }
-
-    #[test]
-    fn test_big_bitv_tests() {
-        let v = from_bytes([ // 88 bits
-            0, 0, 0, 0,
-            0, 0, 0, 0,
-            0, 0, 0]);
-        assert!(!v.all());
-        assert!(!v.any());
-        assert!(v.none());
-
-        let v = from_bytes([ // 88 bits
-            0, 0, 0b00010100, 0,
-            0, 0, 0, 0b00110100,
-            0, 0, 0]);
-        assert!(!v.all());
-        assert!(v.any());
-        assert!(!v.none());
-
-        let v = from_bytes([ // 88 bits
-            0xFF, 0xFF, 0xFF, 0xFF,
-            0xFF, 0xFF, 0xFF, 0xFF,
-            0xFF, 0xFF, 0xFF]);
-        assert!(v.all());
-        assert!(v.any());
-        assert!(!v.none());
-    }
-
     fn rng() -> rand::IsaacRng {
         let seed = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
         rand::SeedableRng::from_seed(seed)

branches/try2/src/libnative/io/addrinfo.rs

@@ -57,7 +57,7 @@ impl GetAddrInfoRequest {
         }
 
         // Collect all the results we found
-        let mut addrs = Vec::new();
+        let mut addrs = ~[];
         let mut rp = res;
         while rp.is_not_null() {
             unsafe {
@@ -80,7 +80,7 @@ impl GetAddrInfoRequest {
 
         unsafe { freeaddrinfo(res); }
 
-        Ok(addrs.move_iter().collect())
+        Ok(addrs)
     }
 }
 

branches/try2/src/libnative/io/file_unix.rs

@@ -18,6 +18,7 @@ use libc::{c_int, c_void};
 use libc;
 use std::mem;
 use std::rt::rtio;
+use std::slice;
 
 use io::{IoResult, retry, keep_going};
 
@@ -415,7 +416,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
     if len == -1 {
         len = 1024; // FIXME: read PATH_MAX from C ffi?
     }
-    let mut buf: Vec<u8> = Vec::with_capacity(len as uint);
+    let mut buf = slice::with_capacity::<u8>(len as uint);
     match retry(|| unsafe {
         libc::readlink(p, buf.as_ptr() as *mut libc::c_char,
                        len as libc::size_t) as libc::c_int