---

yaml
---
r: 154614
b: refs/heads/try2
c: 0b3e43d
h: refs/heads/master
v: v3

Author: bors

[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: 9968ae255495704cb0c3fc1f43d2df2e84c20d5e
+refs/heads/try2: 0b3e43d2a47ecf4908a912c1144942e5216703ea
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/README.md

@@ -71,7 +71,7 @@ To easily build on windows we can use [MSYS2](http://sourceforge.net/projects/ms
 3. With that now start `mingw32_shell.bat` from where you installed MSYS2 (i.e. `C:\msys`).
 4. From there just navigate to where you have Rust's source code, configure and build it:
 
-        $ ./configure --build=i686-pc-mingw32
+        $ ./configure
         $ make && make install
 
 [repo]: https://github.com/rust-lang/rust

branches/try2/configure

@@ -299,13 +299,19 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=apple-darwin
         ;;
 
-    MINGW32*)
+    MINGW*)
+        # msys' `uname` does not print gcc configuration, but prints msys
+        # configuration. so we cannot believe `uname -m`:
+        # msys1 is always i686 and msys2 is always x86_64.
+        # instead, msys defines $MSYSTEM which is MINGW32 on i686 and
+        # MINGW64 on x86_64.
+        CFG_CPUTYPE=i686
         CFG_OSTYPE=pc-mingw32
-        ;;
-
-    MINGW64*)
-        # msys2, MSYSTEM=MINGW64
-        CFG_OSTYPE=w64-mingw32
+        if [ "$MSYSTEM" = MINGW64 ]
+        then
+            CFG_CPUTYPE=x86_64
+            CFG_OSTYPE=w64-mingw32
+        fi
         ;;
 
 # Thad's Cygwin identifers below

branches/try2/src/compiletest/runtest.rs

@@ -17,7 +17,6 @@ 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;
@@ -819,7 +818,6 @@ 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| {
@@ -833,7 +831,6 @@ 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())
     }
@@ -1251,15 +1248,13 @@ 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/try2/src/compiletest/util.rs

@@ -11,7 +11,6 @@
 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
@@ -36,7 +35,6 @@ 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
@@ -50,11 +48,9 @@ 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/try2/src/doc/guide.md

@@ -2021,7 +2021,7 @@ And trying it out:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game 
+$ ./target/guessing_game
 Guess the number!
 The secret number is: 57
 Please input your guess.
@@ -2292,7 +2292,7 @@ print an error message and return. Let's give this a shot:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game 
+$ ./target/guessing_game
 Guess the number!
 The secret number is: 17
 Please input your guess.
@@ -2358,11 +2358,11 @@ Let's try it!
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game 
+$ ./target/guessing_game
 Guess the number!
 The secret number is: 58
 Please input your guess.
-  76  
+  76
 You guessed: 76
 Too big!
 $
@@ -2436,7 +2436,7 @@ that `return`? If we give a non-number answer, we'll `return` and quit. Observe:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game 
+$ ./target/guessing_game
 Guess the number!
 The secret number is: 59
 Please input your guess.
@@ -2569,7 +2569,7 @@ Now we should be good! Let's try:
 ```{rust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game 
+$ ./target/guessing_game
 Guess the number!
 The secret number is: 61
 Please input your guess.
@@ -3325,7 +3325,8 @@ 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 add_three_times_four(x: int) -> int {
+# fn main() {}
+pub fn add_three_times_four(x: int) -> int {
     (x + 3) * 4
 }
 ```
@@ -3717,18 +3718,18 @@ That's a lot to take in. It's also one of the _most_ important concepts in
 all of Rust. Let's see this syntax in action:
 
 ```{rust}
-{ 
+{
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // other code here...
-   
+
 } // privilege 1: when x goes out of scope, this memory is deallocated
 
 /// this function borrows an integer. It's given back automatically when the
 /// function returns.
-fn foo(x: &int) -> &int { x } 
+fn foo(x: &int) -> &int { x }
 
-{ 
+{
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // privilege 2: you may lend that resource, to as many borrowers as you'd like
@@ -3738,14 +3739,14 @@ fn foo(x: &int) -> &int { x }
     foo(&x); // functions can borrow too!
 
     let a = &x; // we can do this alllllll day!
-} 
+}
 
-{ 
+{
     let mut x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     let y = &mut x; // privilege 3: you may lend that resource to a single borrower,
                     // mutably
-}   
+}
 ```
 
 If you are a borrower, you get a few privileges as well, but must also obey a
@@ -4534,7 +4535,7 @@ let one_to_one_hundred = range(0i, 100i).collect();
 ```
 
 As you can see, we call `collect()` on our iterator. `collect()` takes
-as many values as the iterator will give it, and returns a collection 
+as many values as the iterator will give it, and returns a collection
 of the results. So why won't this compile? Rust can't determine what
 type of things you want to collect, and so you need to let it know.
 Here's the version that does compile:
@@ -5507,7 +5508,7 @@ fn main() {
 }
 ```
 
-Whew! This isn't too terrible. You can see that we still `let x = 5i`, 
+Whew! This isn't too terrible. You can see that we still `let x = 5i`,
 but then things get a little bit hairy. Three more bindings get set: a
 static format string, an argument vector, and the aruments. We then
 invoke the `println_args` function with the generated arguments.
@@ -5530,9 +5531,9 @@ There are two circumstances where Rust's safety provisions don't work well.
 The first is when interfacing with C code, and the second is when building
 certain kinds of abstractions.
 
-Rust has support for FFI, (which you can read about in the [FFI
-Guide](guide-ffi.html)) but Rust can't guarantee that the C code will be safe,
-like Rust's will. Therefore, Rust marks such functions with the `unsafe`
+Rust has support for FFI (which you can read about in the [FFI
+Guide](guide-ffi.html)), but can't guarantee that the C code will be safe.
+Therefore, Rust marks such functions with the `unsafe`
 keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust

branches/try2/src/etc/maketest.py

@@ -15,13 +15,14 @@
 # msys1/msys2 automatically converts `/abs/path1:/abs/path2` into
 # `c:\real\abs\path1;c:\real\abs\path2` (semicolons) if shell thinks
 # the value is list of paths.
+# (if there is only one path, it becomes `c:/real/abs/path`.)
 # this causes great confusion and error: shell and Makefile doesn't like
 # windows paths so it is really error-prone. revert it for peace.
 def normalize_path(v):
-    # c:\path -> /c/path
-    if ':\\' in v:
-        v = '/' + v.replace(':\\', '/')
     v = v.replace('\\', '/')
+    # c:/path -> /c/path
+    if ':/' in v:
+        v = '/' + v.replace(':/', '/')
     return v
 
 

branches/try2/src/etc/mklldeps.py

@@ -68,8 +68,6 @@ 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/try2/src/liballoc/heap.rs

@@ -208,6 +208,7 @@ mod imp {
 
 #[cfg(not(jemalloc), unix)]
 mod imp {
+    use core::cmp;
     use core::mem;
     use core::ptr;
     use libc;
@@ -248,7 +249,7 @@ mod imp {
     pub unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint,
                              old_size: uint) -> *mut u8 {
         let new_ptr = allocate(size, align);
-        ptr::copy_memory(new_ptr, ptr as *const u8, old_size);
+        ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
         deallocate(ptr, old_size, align);
         return new_ptr;
     }

branches/try2/src/libcore/iter.rs

@@ -728,6 +728,10 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> {
     /// Return the exact length of the iterator.
     fn len(&self) -> uint {
         let (lower, upper) = self.size_hint();
+        // Note: This assertion is overly defensive, but it checks the invariant
+        // guaranteed by the trait. If this trait were rust-internal,
+        // we could use debug_assert!; assert_eq! will check all Rust user
+        // implementations too.
         assert_eq!(upper, Some(lower));
         lower
     }
@@ -1195,21 +1199,20 @@ impl<A, B, T: ExactSize<A>, U: ExactSize<B>> DoubleEndedIterator<(A, B)>
 for Zip<T, U> {
     #[inline]
     fn next_back(&mut self) -> Option<(A, B)> {
-        let (a_sz, a_upper) = self.a.size_hint();
-        let (b_sz, b_upper) = self.b.size_hint();
-        assert!(a_upper == Some(a_sz));
-        assert!(b_upper == Some(b_sz));
-        if a_sz < b_sz {
-            for _ in range(0, b_sz - a_sz) { self.b.next_back(); }
-        } else if a_sz > b_sz {
-            for _ in range(0, a_sz - b_sz) { self.a.next_back(); }
-        }
-        let (a_sz, _) = self.a.size_hint();
-        let (b_sz, _) = self.b.size_hint();
-        assert!(a_sz == b_sz);
+        let a_sz = self.a.len();
+        let b_sz = self.b.len();
+        if a_sz != b_sz {
+            // Adjust a, b to equal length
+            if a_sz > b_sz {
+                for _ in range(0, a_sz - b_sz) { self.a.next_back(); }
+            } else {
+                for _ in range(0, b_sz - a_sz) { self.b.next_back(); }
+            }
+        }
         match (self.a.next_back(), self.b.next_back()) {
             (Some(x), Some(y)) => Some((x, y)),
-            _ => None
+            (None, None) => None,
+            _ => unreachable!(),
         }
     }
 }
@@ -1395,9 +1398,8 @@ impl<A, T: ExactSize<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> {
     fn next_back(&mut self) -> Option<(uint, A)> {
         match self.iter.next_back() {
             Some(a) => {
-                let (lower, upper) = self.iter.size_hint();
-                assert!(upper == Some(lower));
-                Some((self.count + lower, a))
+                let len = self.iter.len();
+                Some((self.count + len, a))
             }
             _ => None
         }