---

yaml
---
r: 63423
b: refs/heads/snap-stage3
c: 4efb17f
h: refs/heads/master
i:
  63421: 35ab70d
  63419: f68ebb1
  63415: 95e59dc
  63407: b0d3d9d
  63391: dc72069
  63359: 6183ed3
v: v3

Author: yichoi

[refs]

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

branches/snap-stage3/mk/tests.mk

@@ -122,9 +122,7 @@ CFG_ADB_TEST_DIR=/data/tmp
 $(info check: android device test dir $(CFG_ADB_TEST_DIR) ready \
  $(shell adb remount 1>/dev/null) \
  $(shell adb shell mkdir $(CFG_ADB_TEST_DIR) 1>/dev/null) \
- $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*.so 1>/dev/null) \
- $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*-arm-linux-androideabi 1>/dev/null) \
- $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*-arm-linux-androideabi.* 1>/dev/null) \
+ $(shell adb shell rm -rf $(CFG_ADB_TEST_DIR)/* 1>/dev/null) \
  $(shell adb push $(S)src/etc/adb_run_wrapper.sh $(CFG_ADB_TEST_DIR) 1>/dev/null) \
  $(shell adb push $(CFG_ANDROID_CROSS_PATH)/arm-linux-androideabi/lib/armv7-a/libgnustl_shared.so \
                   $(CFG_ADB_TEST_DIR) 1>/dev/null) \

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

@@ -61,7 +61,7 @@ pub use path::Path;
 pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::RawPtr;
-pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, ToBytesConsume};
+pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr};
 pub use str::{Str, StrVector, StrSlice, OwnedStr, StrUtil, NullTerminatedStr};
 pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;

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

@@ -2202,12 +2202,6 @@ impl<'self> Iterator<u8> for StrBytesRevIterator<'self> {
     }
 }
 
-// This works because every lifetime is a sub-lifetime of 'static
-impl<'self> Zero for &'self str {
-    fn zero() -> &'self str { "" }
-    fn is_zero(&self) -> bool { self.is_empty() }
-}
-
 impl Zero for ~str {
     fn zero() -> ~str { ~"" }
     fn is_zero(&self) -> bool { self.len() == 0 }
@@ -3323,18 +3317,4 @@ mod tests {
         t("zzz", "zz", ~["","z"]);
         t("zzzzz", "zz", ~["","","z"]);
     }
-
-    #[test]
-    fn test_str_zero() {
-        use num::Zero;
-        fn t<S: Zero + Str>() {
-            let s: S = Zero::zero();
-            assert_eq!(s.as_slice(), "");
-            assert!(s.is_zero());
-        }
-
-        t::<&str>();
-        t::<@str>();
-        t::<~str>();
-    }
 }

branches/snap-stage3/src/libstd/str/ascii.rs

@@ -17,9 +17,8 @@ use cast;
 use old_iter::BaseIter;
 use iterator::IteratorUtil;
 use vec::{CopyableVector, ImmutableVector, OwnedVector};
-use to_bytes::IterBytes;
 
-/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
+/// Datatype to hold one ascii character. It is 8 bit long.
 #[deriving(Clone, Eq)]
 pub struct Ascii { priv chr: u8 }
 
@@ -73,9 +72,6 @@ pub trait AsciiCast<T> {
     /// Convert to an ascii type
     fn to_ascii(&self) -> T;
 
-    /// Convert to an ascii type, not doing any range asserts
-    unsafe fn to_ascii_nocheck(&self) -> T;
-
     /// Check if convertible to ascii
     fn is_ascii(&self) -> bool;
 }
@@ -84,12 +80,7 @@ impl<'self> AsciiCast<&'self[Ascii]> for &'self [u8] {
     #[inline(always)]
     fn to_ascii(&self) -> &'self[Ascii] {
         assert!(self.is_ascii());
-        unsafe {self.to_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn to_ascii_nocheck(&self) -> &'self[Ascii] {
-        cast::transmute(*self)
+        unsafe{ cast::transmute(*self) }
     }
 
     #[inline(always)]
@@ -105,13 +96,8 @@ impl<'self> AsciiCast<&'self[Ascii]> for &'self str {
     #[inline(always)]
     fn to_ascii(&self) -> &'self[Ascii] {
         assert!(self.is_ascii());
-        unsafe {self.to_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn to_ascii_nocheck(&self) -> &'self[Ascii] {
-        let (p,len): (*u8, uint) = cast::transmute(*self);
-        cast::transmute((p, len - 1))
+        let (p,len): (*u8, uint) = unsafe{ cast::transmute(*self) };
+        unsafe{ cast::transmute((p, len - 1))}
     }
 
     #[inline(always)]
@@ -124,11 +110,6 @@ impl AsciiCast<Ascii> for u8 {
     #[inline(always)]
     fn to_ascii(&self) -> Ascii {
         assert!(self.is_ascii());
-        unsafe {self.to_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn to_ascii_nocheck(&self) -> Ascii {
         Ascii{ chr: *self }
     }
 
@@ -142,11 +123,6 @@ impl AsciiCast<Ascii> for char {
     #[inline(always)]
     fn to_ascii(&self) -> Ascii {
         assert!(self.is_ascii());
-        unsafe {self.to_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn to_ascii_nocheck(&self) -> Ascii {
         Ascii{ chr: *self as u8 }
     }
 
@@ -159,38 +135,26 @@ impl AsciiCast<Ascii> for char {
 /// Trait for copyless casting to an ascii vector.
 pub trait OwnedAsciiCast {
     /// Take ownership and cast to an ascii vector without trailing zero element.
-    fn into_ascii(self) -> ~[Ascii];
-
-    /// Take ownership and cast to an ascii vector without trailing zero element.
-    /// Does not perform validation checks.
-    unsafe fn into_ascii_nocheck(self) -> ~[Ascii];
+    fn to_ascii_consume(self) -> ~[Ascii];
 }
 
 impl OwnedAsciiCast for ~[u8] {
     #[inline(always)]
-    fn into_ascii(self) -> ~[Ascii] {
+    fn to_ascii_consume(self) -> ~[Ascii] {
         assert!(self.is_ascii());
-        unsafe {self.into_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn into_ascii_nocheck(self) -> ~[Ascii] {
-        cast::transmute(self)
+        unsafe {cast::transmute(self)}
     }
 }
 
 impl OwnedAsciiCast for ~str {
     #[inline(always)]
-    fn into_ascii(self) -> ~[Ascii] {
+    fn to_ascii_consume(self) -> ~[Ascii] {
         assert!(self.is_ascii());
-        unsafe {self.into_ascii_nocheck()}
-    }
-
-    #[inline(always)]
-    unsafe fn into_ascii_nocheck(self) -> ~[Ascii] {
-        let mut r: ~[Ascii] = cast::transmute(self);
-        r.pop();
-        r
+        let mut s = self;
+        unsafe {
+            str::raw::pop_byte(&mut s);
+            cast::transmute(s)
+        }
     }
 }
 
@@ -205,8 +169,6 @@ pub trait AsciiStr {
     /// Convert to vector representing a upper cased ascii string.
     fn to_upper(&self) -> ~[Ascii];
 
-    /// Compares two Ascii strings ignoring case
-    fn eq_ignore_case(self, other: &[Ascii]) -> bool;
 }
 
 impl<'self> AsciiStr for &'self [Ascii] {
@@ -226,45 +188,20 @@ impl<'self> AsciiStr for &'self [Ascii] {
     fn to_upper(&self) -> ~[Ascii] {
         self.map(|a| a.to_upper())
     }
-
-    #[inline(always)]
-    fn eq_ignore_case(self, other: &[Ascii]) -> bool {
-        do self.iter().zip(other.iter()).all |(&a, &b)| { a.eq_ignore_case(b) }
-    }
 }
 
 impl ToStrConsume for ~[Ascii] {
     #[inline(always)]
-    fn into_str(self) -> ~str {
+    fn to_str_consume(self) -> ~str {
         let mut cpy = self;
         cpy.push(0u8.to_ascii());
         unsafe {cast::transmute(cpy)}
     }
 }
 
-impl IterBytes for Ascii {
-    #[inline(always)]
-    fn iter_bytes(&self, _lsb0: bool, f: &fn(buf: &[u8]) -> bool) -> bool {
-        f([self.to_byte()])
-    }
-}
-
-/// Trait to convert to a owned byte array by consuming self
-pub trait ToBytesConsume {
-    /// Converts to a owned byte array by consuming self
-    fn into_bytes(self) -> ~[u8];
-}
-
-impl ToBytesConsume for ~[Ascii] {
-    fn into_bytes(self) -> ~[u8] {
-        unsafe {cast::transmute(self)}
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use to_bytes::ToBytes;
 
     macro_rules! v2ascii (
         ( [$($e:expr),*]) => ( [$(Ascii{chr:$e}),*]);
@@ -308,8 +245,6 @@ mod tests {
         assert_eq!("YMCA".to_ascii().to_lower().to_str_ascii(), ~"ymca");
         assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().to_str_ascii(), ~"ABCDEFXYZ:.;");
 
-        assert!("aBcDeF&?#".to_ascii().eq_ignore_case("AbCdEf&?#".to_ascii()));
-
         assert!("".is_ascii());
         assert!("a".is_ascii());
         assert!(!"\u2009".is_ascii());
@@ -318,22 +253,21 @@ mod tests {
 
     #[test]
     fn test_owned_ascii_vec() {
-        assert_eq!((~"( ;").into_ascii(), v2ascii!(~[40, 32, 59]));
-        assert_eq!((~[40u8, 32u8, 59u8]).into_ascii(), v2ascii!(~[40, 32, 59]));
+        // FIXME: #4318 Compiler crashes on moving self
+        //assert_eq!(~"( ;".to_ascii_consume(), v2ascii!(~[40, 32, 59]));
+        //assert_eq!(~[40u8, 32u8, 59u8].to_ascii_consume(), v2ascii!(~[40, 32, 59]));
+        //assert_eq!(~"( ;".to_ascii_consume_with_null(), v2ascii!(~[40, 32, 59, 0]));
+        //assert_eq!(~[40u8, 32u8, 59u8].to_ascii_consume_with_null(),
+        //           v2ascii!(~[40, 32, 59, 0]));
     }
 
     #[test]
     fn test_ascii_to_str() { assert_eq!(v2ascii!([40, 32, 59]).to_str_ascii(), ~"( ;"); }
 
     #[test]
-    fn test_ascii_into_str() {
-        assert_eq!(v2ascii!(~[40, 32, 59]).into_str(), ~"( ;");
-    }
-
-    #[test]
-    fn test_ascii_to_bytes() {
-        assert_eq!(v2ascii!(~[40, 32, 59]).to_bytes(false), ~[40u8, 32u8, 59u8]);
-        assert_eq!(v2ascii!(~[40, 32, 59]).into_bytes(), ~[40u8, 32u8, 59u8]);
+    fn test_ascii_to_str_consume() {
+        // FIXME: #4318 Compiler crashes on moving self
+        //assert_eq!(v2ascii!(~[40, 32, 59]).to_str_consume(), ~"( ;");
     }
 
     #[test] #[should_fail]

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

@@ -31,7 +31,7 @@ pub trait ToStr {
 /// Trait for converting a type to a string, consuming it in the process.
 pub trait ToStrConsume {
     /// Cosume and convert to a string.
-    fn into_str(self) -> ~str;
+    fn to_str_consume(self) -> ~str;
 }
 
 impl ToStr for () {

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

@@ -2629,12 +2629,6 @@ impl<A:Clone> Clone for ~[A] {
     }
 }
 
-// This works because every lifetime is a sub-lifetime of 'static
-impl<'self, A> Zero for &'self [A] {
-    fn zero() -> &'self [A] { &'self [] }
-    fn is_zero(&self) -> bool { self.is_empty() }
-}
-
 impl<A> Zero for ~[A] {
     fn zero() -> ~[A] { ~[] }
     fn is_zero(&self) -> bool { self.len() == 0 }
@@ -4299,20 +4293,4 @@ mod tests {
         }
         assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
     }
-
-    #[test]
-    fn test_vec_zero() {
-        use num::Zero;
-        macro_rules! t (
-            ($ty:ty) => {
-                let v: $ty = Zero::zero();
-                assert!(v.is_empty());
-                assert!(v.is_zero());
-            }
-        );
-
-        t!(&[int]);
-        t!(@[int]);
-        t!(~[int]);
-    }
 }