---

yaml
---
r: 129501
b: refs/heads/snap-stage3
c: cb29492
h: refs/heads/master
i:
  129499: efded4e
v: v3

Author: Swatinem

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 566b470e138e929e8a93d613372db1ba177c494f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 03fd90be459650160a4edefbc78588a938db2f8c
+refs/heads/snap-stage3: cb29492e77ff24d56ebc06ecfbd9b2c9bcc6e315
 refs/heads/try: 80b45ddbd351f0a4a939c3a3c4e20b4defec4b35
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/configure

@@ -635,7 +635,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-6]*)
+        (3.[2-5]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)

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

@@ -17,6 +17,7 @@ use header;
 use procsrv;
 use util::logv;
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 use util;
 
 use std::io::File;
@@ -818,6 +819,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     }).collect::<Vec<String> >();
 
     #[cfg(target_os = "windows")]
+    #[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
     fn to_lower( s : &str ) -> String {
         let i = s.chars();
         let c : Vec<char> = i.map( |c| {
@@ -831,6 +833,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     }
 
     #[cfg(target_os = "windows")]
+    #[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
@@ -1248,13 +1251,15 @@ fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
 }
 
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
 }
 
 // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
 // for diagnostic purposes
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 fn lib_path_cmd_prefix(path: &str) -> String {
     format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
 }

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

@@ -11,6 +11,7 @@
 use common::Config;
 
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 use std::os::getenv;
 
 /// Conversion table from triple OS name to Rust SYSNAME
@@ -35,6 +36,7 @@ pub fn get_os(triple: &str) -> &'static str {
 }
 
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 pub fn make_new_path(path: &str) -> String {
 
     // Windows just uses PATH as the library search path, so we have to
@@ -48,9 +50,11 @@ pub fn make_new_path(path: &str) -> String {
 }
 
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 pub fn lib_path_env_var() -> &'static str { "PATH" }
 
 #[cfg(target_os = "windows")]
+#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 pub fn path_div() -> &'static str { ";" }
 
 pub fn logv(config: &Config, s: String) {

branches/snap-stage3/src/doc/guide.md

@@ -1073,8 +1073,8 @@ destructuring `let`.
 ## Enums
 
 Finally, Rust has a "sum type", an **enum**. Enums are an incredibly useful
-feature of Rust, and are used throughout the standard library. This is an enum
-that is provided by the Rust standard library:
+feature of Rust, and are used throughout the standard library. Enums look
+like this:
 
 ```{rust}
 enum Ordering {
@@ -1084,8 +1084,9 @@ enum Ordering {
 }
 ```
 
-An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given
-time. Here's an example:
+This is an enum that is provided by the Rust standard library. An `Ordering`
+can only be _one_ of `Less`, `Equal`, or `Greater` at any given time. Here's
+an example:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -2896,11 +2897,9 @@ pub fn print_hello() {
 }
 ```
 
-When we include a module like this, we don't need to make the `mod` declaration
-in `hello.rs`, because it's already been declared in `lib.rs`. `hello.rs` just
-contains the body of the module which is defined (by the `pub mod hello`) in
-`lib.rs`.  This helps prevent 'rightward drift': when you end up indenting so
-many times that your code is hard to read.
+When we include a module like this, we don't need to make the `mod` declaration,
+it's just understood. This helps prevent 'rightward drift': when you end up
+indenting so many times that your code is hard to read.
 
 Finally, make a new directory, `src/goodbye`, and make a new file in it,
 `src/goodbye/mod.rs`:
@@ -3325,8 +3324,7 @@ To do that, we'll need to make a new module. Make a new file, `src/lib.rs`,
 and put this in it:
 
 ```{rust}
-# fn main() {}
-pub fn add_three_times_four(x: int) -> int {
+fn add_three_times_four(x: int) -> int {
     (x + 3) * 4
 }
 ```

branches/snap-stage3/src/etc/mklldeps.py

@@ -68,6 +68,8 @@ def run(args):
     ]
 
     f.write("#[cfg(" + ', '.join(cfg) + ")]\n")
+    if os == "windows": # NOTE: Remove after snapshot
+        f.write("#[cfg(stage0, target_arch = \"%s\", target_os = \"win32\")]\n" % (arch,))
 
     version = run([llconfig, '--version']).strip()
 

branches/snap-stage3/src/libarena/lib.rs

@@ -563,7 +563,7 @@ mod tests {
 
     struct Noncopy {
         string: String,
-        array: Vec<int>,
+        array: Vec<int> ,
     }
 
     #[test]

branches/snap-stage3/src/libcollections/bitv.rs

@@ -2566,9 +2566,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
-            }
+            bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
             &bitv
         })
     }
@@ -2578,9 +2576,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
-            }
+            bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
             &bitv
         })
     }
@@ -2590,9 +2586,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % uint::BITS, true);
-            }
+            bitv.set((r.next_u32() as uint) % uint::BITS, true);
             &bitv
         })
     }
@@ -2602,9 +2596,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.insert((r.next_u32() as uint) % uint::BITS);
-            }
+            bitv.insert((r.next_u32() as uint) % uint::BITS);
             &bitv
         })
     }
@@ -2614,9 +2606,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
-                bitv.insert((r.next_u32() as uint) % BENCH_BITS);
-            }
+            bitv.insert((r.next_u32() as uint) % BENCH_BITS);
             &bitv
         })
     }
@@ -2626,33 +2616,29 @@ mod tests {
         let mut b1 = Bitv::with_capacity(BENCH_BITS, false);
         let b2 = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            b1.union(&b2)
+            b1.union(&b2);
         })
     }
 
     #[bench]
-    fn bench_bitv_small_iter(b: &mut Bencher) {
+    fn bench_btv_small_iter(b: &mut Bencher) {
         let bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
-            let mut sum = 0;
-            for _ in range(0u, 10) {
-                for pres in bitv.iter() {
-                    sum += pres as uint;
-                }
+            let mut _sum = 0;
+            for pres in bitv.iter() {
+                _sum += pres as uint;
             }
-            sum
         })
     }
 
     #[bench]
     fn bench_bitv_big_iter(b: &mut Bencher) {
         let bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            let mut sum = 0;
+            let mut _sum = 0;
             for pres in bitv.iter() {
-                sum += pres as uint;
+                _sum += pres as uint;
             }
-            sum
         })
     }
 
@@ -2661,11 +2647,10 @@ mod tests {
         let bitv = BitvSet::from_bitv(from_fn(BENCH_BITS,
                                               |idx| {idx % 3 == 0}));
         b.iter(|| {
-            let mut sum = 0;
+            let mut _sum = 0;
             for idx in bitv.iter() {
-                sum += idx;
+                _sum += idx;
             }
-            sum
         })
     }
 }

branches/snap-stage3/src/libcollections/priority_queue.rs

@@ -529,9 +529,10 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
 }
 
 impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
-    fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> PriorityQueue<T> {
-        let vec: Vec<T> = iter.collect();
-        PriorityQueue::from_vec(vec)
+    fn from_iter<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {
+        let mut q = PriorityQueue::new();
+        q.extend(iter);
+        q
     }
 }
 

branches/snap-stage3/src/libcore/mem.rs

@@ -19,16 +19,6 @@ use ptr;
 
 pub use intrinsics::transmute;
 
-/// Moves a thing into the void.
-///
-/// The forget function will take ownership of the provided value but neglect
-/// to run any required cleanup or memory management operations on it.
-///
-/// This function is the unsafe version of the `drop` function because it does
-/// not run any destructors.
-#[stable]
-pub use intrinsics::forget;
-
 /// Returns the size of a type in bytes.
 #[inline]
 #[stable]
@@ -347,6 +337,17 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 #[stable]
 pub fn drop<T>(_x: T) { }
 
+/// Moves a thing into the void.
+///
+/// The forget function will take ownership of the provided value but neglect
+/// to run any required cleanup or memory management operations on it.
+///
+/// This function is the unsafe version of the `drop` function because it does
+/// not run any destructors.
+#[inline]
+#[stable]
+pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing) }
+
 /// Interprets `src` as `&U`, and then reads `src` without moving the contained
 /// value.
 ///

branches/snap-stage3/src/libcore/str.rs

@@ -419,8 +419,6 @@ struct TwoWaySearcher {
     memory: uint
 }
 
-// This is the Two-Way search algorithm, which was introduced in the paper:
-// Crochemore, M., Perrin, D., 1991, Two-way string-matching, Journal of the ACM 38(3):651-675.
 impl TwoWaySearcher {
     fn new(needle: &[u8]) -> TwoWaySearcher {
         let (critPos1, period1) = TwoWaySearcher::maximal_suffix(needle, false);
@@ -439,14 +437,7 @@ impl TwoWaySearcher {
         let byteset = needle.iter()
                             .fold(0, |a, &b| (1 << ((b & 0x3f) as uint)) | a);
 
-
-        // The logic here (calculating critPos and period, the final if statement to see which
-        // period to use for the TwoWaySearcher) is essentially an implementation of the
-        // "small-period" function from the paper (p. 670)
-        //
-        // In the paper they check whether `needle.slice_to(critPos)` is a suffix of
-        // `needle.slice(critPos, critPos + period)`, which is precisely what this does
-        if needle.slice_to(critPos) == needle.slice(period, period + critPos) {
+        if needle.slice_to(critPos) == needle.slice_from(needle.len() - critPos) {
             TwoWaySearcher {
                 critPos: critPos,
                 period: period,
@@ -517,9 +508,6 @@ impl TwoWaySearcher {
         }
     }
 
-    // returns (i, p) where i is the "critical position", the starting index of
-    // of maximal suffix, and p is the period of the suffix
-    // see p. 668 of the paper
     #[inline]
     fn maximal_suffix(arr: &[u8], reversed: bool) -> (uint, uint) {
         let mut left = -1; // Corresponds to i in the paper

branches/snap-stage3/src/libcoretest/str.rs

@@ -8,27 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn check_contains_all_substrings(s: &str) {
-    assert!(s.contains(""));
-    for i in range(0, s.len()) {
-        for j in range(i+1, s.len() + 1) {
-            assert!(s.contains(s.slice(i, j)));
-        }
-    }
-}
-
 #[test]
 fn strslice_issue_16589() {
     assert!("bananas".contains("nana"));
-
-    // prior to the fix for #16589, x.contains("abcdabcd") returned false
-    // test all substrings for good measure
-    check_contains_all_substrings("012345678901234567890123456789bcdabcdabcd");
-}
-
-
-#[test]
-fn test_strslice_contains() {
-    let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'";
-    check_contains_all_substrings(x);
 }