---

yaml
---
r: 129516
b: refs/heads/snap-stage3
c: 471862f
h: refs/heads/master
v: v3

Author: bors

[refs]

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

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/src/libcore/str.rs

@@ -1717,6 +1717,13 @@ pub trait StrSlice<'a> {
     fn utf16_units(&self) -> Utf16CodeUnits<'a>;
 }
 
+#[inline(never)]
+fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
+    assert!(begin <= end);
+    fail!("index {} and/or {} in `{}` do not lie on character boundary",
+          begin, end, s);
+}
+
 impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn contains<'a>(&self, needle: &'a str) -> bool {
@@ -1820,22 +1827,34 @@ impl<'a> StrSlice<'a> for &'a str {
 
     #[inline]
     fn slice(&self, begin: uint, end: uint) -> &'a str {
-        assert!(self.is_char_boundary(begin) && self.is_char_boundary(end),
-                "index {} and/or {} in `{}` do not lie on character boundary", begin,
-                end, *self);
-        unsafe { raw::slice_bytes(*self, begin, end) }
+        // is_char_boundary checks that the index is in [0, .len()]
+        if begin <= end &&
+           self.is_char_boundary(begin) &&
+           self.is_char_boundary(end) {
+            unsafe { raw::slice_unchecked(*self, begin, end) }
+        } else {
+            slice_error_fail(*self, begin, end)
+        }
     }
 
     #[inline]
     fn slice_from(&self, begin: uint) -> &'a str {
-        self.slice(begin, self.len())
+        // is_char_boundary checks that the index is in [0, .len()]
+        if self.is_char_boundary(begin) {
+            unsafe { raw::slice_unchecked(*self, begin, self.len()) }
+        } else {
+            slice_error_fail(*self, begin, self.len())
+        }
     }
 
     #[inline]
     fn slice_to(&self, end: uint) -> &'a str {
-        assert!(self.is_char_boundary(end), "index {} in `{}` does not lie on \
-                a character boundary", end, *self);
-        unsafe { raw::slice_bytes(*self, 0, end) }
+        // is_char_boundary checks that the index is in [0, .len()]
+        if self.is_char_boundary(end) {
+            unsafe { raw::slice_unchecked(*self, 0, end) }
+        } else {
+            slice_error_fail(*self, 0, end)
+        }
     }
 
     fn slice_chars(&self, begin: uint, end: uint) -> &'a str {
@@ -1910,9 +1929,10 @@ impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn is_char_boundary(&self, index: uint) -> bool {
         if index == self.len() { return true; }
-        if index > self.len() { return false; }
-        let b = self.as_bytes()[index];
-        return b < 128u8 || b >= 192u8;
+        match self.as_bytes().get(index) {
+            None => false,
+            Some(&b) => b < 128u8 || b >= 192u8,
+        }
     }
 
     #[inline]

branches/snap-stage3/src/libstd/macros.rs

@@ -96,7 +96,7 @@ macro_rules! fail(
 macro_rules! assert(
     ($cond:expr) => (
         if !$cond {
-            fail!("assertion failed: {:s}", stringify!($cond))
+            fail!(concat!("assertion failed: ", stringify!($cond)))
         }
     );
     ($cond:expr, $($arg:expr),+) => (

branches/snap-stage3/src/libunicode/u_char.rs

@@ -20,7 +20,13 @@ use tables::{derived_property, property, general_category, conversions, charwidt
 
 /// Returns whether the specified `char` is considered a Unicode alphabetic
 /// code point
-pub fn is_alphabetic(c: char) -> bool   { derived_property::Alphabetic(c) }
+pub fn is_alphabetic(c: char) -> bool {
+    match c {
+        'a' .. 'z' | 'A' .. 'Z' => true,
+        c if c > '\x7f' => derived_property::Alphabetic(c),
+        _ => false
+    }
+}
 
 /// Returns whether the specified `char` satisfies the 'XID_Start' Unicode property
 ///
@@ -44,15 +50,27 @@ pub fn is_XID_continue(c: char) -> bool { derived_property::XID_Continue(c) }
 /// This is defined according to the terms of the Unicode Derived Core Property 'Lowercase'.
 ///
 #[inline]
-pub fn is_lowercase(c: char) -> bool { derived_property::Lowercase(c) }
+pub fn is_lowercase(c: char) -> bool {
+    match c {
+        'a' .. 'z' => true,
+        c if c > '\x7f' => derived_property::Lowercase(c),
+        _ => false
+    }
+}
 
 ///
 /// Indicates whether a `char` is in upper case
 ///
 /// This is defined according to the terms of the Unicode Derived Core Property 'Uppercase'.
 ///
 #[inline]
-pub fn is_uppercase(c: char) -> bool { derived_property::Uppercase(c) }
+pub fn is_uppercase(c: char) -> bool {
+    match c {
+        'A' .. 'Z' => true,
+        c if c > '\x7f' => derived_property::Uppercase(c),
+        _ => false
+    }
+}
 
 ///
 /// Indicates whether a `char` is whitespace
@@ -61,10 +79,11 @@ pub fn is_uppercase(c: char) -> bool { derived_property::Uppercase(c) }
 ///
 #[inline]
 pub fn is_whitespace(c: char) -> bool {
-    // As an optimization ASCII whitespace characters are checked separately
-    c == ' '
-        || ('\x09' <= c && c <= '\x0d')
-        || property::White_Space(c)
+    match c {
+        ' ' | '\x09' .. '\x0d' => true,
+        c if c > '\x7f' => property::White_Space(c),
+        _ => false
+    }
 }
 
 ///
@@ -75,8 +94,8 @@ pub fn is_whitespace(c: char) -> bool {
 ///
 #[inline]
 pub fn is_alphanumeric(c: char) -> bool {
-    derived_property::Alphabetic(c)
-        || general_category::N(c)
+    is_alphabetic(c)
+        || is_digit(c)
 }
 
 ///
@@ -91,7 +110,11 @@ pub fn is_control(c: char) -> bool { general_category::Cc(c) }
 /// Indicates whether the `char` is numeric (Nd, Nl, or No)
 #[inline]
 pub fn is_digit(c: char) -> bool {
-    general_category::N(c)
+    match c {
+        '0' .. '9' => true,
+        c if c > '\x7f' => general_category::N(c),
+        _ => false
+    }
 }
 
 /// Convert a char to its uppercase equivalent

branches/snap-stage3/src/test/run-pass/cast-in-array-size.rs

@@ -0,0 +1,19 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+// issues #10618 and #16382
+static SIZE: int = 25;
+
+fn main() {
+    let _a: [bool, ..1 as uint];
+    let _b: [int, ..SIZE as uint] = [1, ..SIZE as uint];
+    let _c: [bool, ..'\n' as uint] = [true, ..'\n' as uint];
+}