---

yaml
---
r: 149385
b: refs/heads/try2
c: cb3a419
h: refs/heads/master
i:
  149383: 64760cc
v: v3

Author: milibopp

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

branches/try2/src/libextra/test.rs

@@ -315,15 +315,12 @@ pub fn opt_shard(maybestr: Option<~str>) -> Option<(uint,uint)> {
     match maybestr {
         None => None,
         Some(s) => {
-            let vector = s.split('.').to_owned_vec();
-            if vector.len() == 2 {
-                match (from_str::<uint>(vector[0]),
-                       from_str::<uint>(vector[1])) {
-                    (Some(a), Some(b)) => Some((a, b)),
+            match s.split('.').to_owned_vec() {
+                [a, b] => match (from_str::<uint>(a), from_str::<uint>(b)) {
+                    (Some(a), Some(b)) => Some((a,b)),
                     _ => None
-                }
-            } else {
-                None
+                },
+                _ => None
             }
         }
     }
@@ -558,7 +555,7 @@ impl<T: Writer> ConsoleTestState<T> {
                 }
             }
         }
-        if_ok!(self.write_plain(format!("result of ratchet: {} metrics added, \
+        if_ok!(self.write_plain(format!("result of ratchet: {} matrics added, \
                                         {} removed, {} improved, {} regressed, \
                                         {} noise\n",
                                        added, removed, improved, regressed,

branches/try2/src/libextra/url.rs

@@ -55,17 +55,6 @@ pub struct Url {
     fragment: Option<~str>
 }
 
-#[deriving(Clone, Eq)]
-pub struct Path {
-    /// The path component of a URL, for example `/foo/bar`.
-    path: ~str,
-    /// The query component of a URL.  `~[(~"baz", ~"qux")]` represents the
-    /// fragment `baz=qux` in the above example.
-    query: Query,
-    /// The fragment component, such as `quz`.  Doesn't include the leading `#` character.
-    fragment: Option<~str>
-}
-
 /// An optional subcomponent of a URI authority component.
 #[deriving(Clone, Eq)]
 pub struct UserInfo {
@@ -99,19 +88,6 @@ impl Url {
     }
 }
 
-impl Path {
-    pub fn new(path: ~str,
-               query: Query,
-               fragment: Option<~str>)
-               -> Path {
-        Path {
-            path: path,
-            query: query,
-            fragment: fragment,
-        }
-    }
-}
-
 impl UserInfo {
     #[inline]
     pub fn new(user: ~str, pass: Option<~str>) -> UserInfo {
@@ -751,21 +727,6 @@ pub fn from_str(rawurl: &str) -> Result<Url, ~str> {
     Ok(Url::new(scheme, userinfo, host, port, path, query, fragment))
 }
 
-pub fn path_from_str(rawpath: &str) -> Result<Path, ~str> {
-    let (path, rest) = match get_path(rawpath, false) {
-        Ok(val) => val,
-        Err(e) => return Err(e)
-    };
-
-    // query and fragment
-    let (query, fragment) = match get_query_fragment(rest) {
-        Ok(val) => val,
-        Err(e) => return Err(e),
-    };
-
-    Ok(Path{ path: path, query: query, fragment: fragment })
-}
-
 impl FromStr for Url {
     fn from_str(s: &str) -> Option<Url> {
         match from_str(s) {
@@ -775,15 +736,6 @@ impl FromStr for Url {
     }
 }
 
-impl FromStr for Path {
-    fn from_str(s: &str) -> Option<Path> {
-        match path_from_str(s) {
-            Ok(path) => Some(path),
-            Err(_) => None
-        }
-    }
-}
-
 /**
  * Converts a URL from `Url` to string representation.
  *
@@ -828,45 +780,18 @@ pub fn to_str(url: &Url) -> ~str {
     format!("{}:{}{}{}{}", url.scheme, authority, url.path, query, fragment)
 }
 
-pub fn path_to_str(path: &Path) -> ~str {
-    let query = if path.query.is_empty() {
-        ~""
-    } else {
-        format!("?{}", query_to_str(&path.query))
-    };
-
-    let fragment = match path.fragment {
-        Some(ref fragment) => format!("\\#{}", encode_component(*fragment)),
-        None => ~"",
-    };
-
-    format!("{}{}{}", path.path, query, fragment)
-}
-
 impl ToStr for Url {
     fn to_str(&self) -> ~str {
         to_str(self)
     }
 }
 
-impl ToStr for Path {
-    fn to_str(&self) -> ~str {
-        path_to_str(self)
-    }
-}
-
 impl IterBytes for Url {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         self.to_str().iter_bytes(lsb0, f)
     }
 }
 
-impl IterBytes for Path {
-    fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        self.to_str().iter_bytes(lsb0, f)
-    }
-}
-
 // Put a few tests outside of the 'test' module so they can test the internal
 // functions and those functions don't need 'pub'
 
@@ -974,17 +899,6 @@ mod tests {
         assert_eq!(&u.fragment, &Some(~"something"));
     }
 
-    #[test]
-    fn test_path_parse() {
-        let path = ~"/doc/~u?s=v#something";
-
-        let up = path_from_str(path);
-        let u = up.unwrap();
-        assert_eq!(&u.path, &~"/doc/~u");
-        assert_eq!(&u.query, &~[(~"s", ~"v")]);
-        assert_eq!(&u.fragment, &Some(~"something"));
-    }
-
     #[test]
     fn test_url_parse_host_slash() {
         let urlstr = ~"http://0.42.42.42/";
@@ -993,13 +907,6 @@ mod tests {
         assert!(url.path == ~"/");
     }
 
-    #[test]
-    fn test_path_parse_host_slash() {
-        let pathstr = ~"/";
-        let path = path_from_str(pathstr).unwrap();
-        assert!(path.path == ~"/");
-    }
-
     #[test]
     fn test_url_host_with_port() {
         let urlstr = ~"scheme://host:1234";
@@ -1023,27 +930,13 @@ mod tests {
         assert!(url.path == ~"/file_name.html");
     }
 
-    #[test]
-    fn test_path_with_underscores() {
-        let pathstr = ~"/file_name.html";
-        let path = path_from_str(pathstr).unwrap();
-        assert!(path.path == ~"/file_name.html");
-    }
-
     #[test]
     fn test_url_with_dashes() {
         let urlstr = ~"http://dotcom.com/file-name.html";
         let url = from_str(urlstr).unwrap();
         assert!(url.path == ~"/file-name.html");
     }
 
-    #[test]
-    fn test_path_with_dashes() {
-        let pathstr = ~"/file-name.html";
-        let path = path_from_str(pathstr).unwrap();
-        assert!(path.path == ~"/file-name.html");
-    }
-
     #[test]
     fn test_no_scheme() {
         assert!(get_scheme("noschemehere.html").is_err());
@@ -1124,14 +1017,6 @@ mod tests {
         assert!(u.query == ~[(~"ba%d ", ~"#&+")]);
     }
 
-    #[test]
-    fn test_path_component_encoding() {
-        let path = ~"/doc%20uments?ba%25d%20=%23%26%2B";
-        let p = path_from_str(path).unwrap();
-        assert!(p.path == ~"/doc uments");
-        assert!(p.query == ~[(~"ba%d ", ~"#&+")]);
-    }
-
     #[test]
     fn test_url_without_authority() {
         let url = ~"mailto:test@email.com";

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

@@ -130,25 +130,27 @@ fn helper(input: libc::c_int, messages: Port<Req>) {
     }
 
     'outer: loop {
-        let timeout = if active.len() == 0 {
+        let timeout = match active {
             // Empty array? no timeout (wait forever for the next request)
-            ptr::null()
-        } else {
-            let now = now();
-            // If this request has already expired, then signal it and go
-            // through another iteration
-            if active[0].target <= now {
-                signal(&mut active, &mut dead);
-                continue;
-            }
+            [] => ptr::null(),
+
+            [~Inner { target, .. }, ..] => {
+                let now = now();
+                // If this request has already expired, then signal it and go
+                // through another iteration
+                if target <= now {
+                    signal(&mut active, &mut dead);
+                    continue;
+                }
 
-            // The actual timeout listed in the requests array is an
-            // absolute date, so here we translate the absolute time to a
-            // relative time.
-            let tm = active[0].target - now;
-            timeout.tv_sec = (tm / 1000) as libc::time_t;
-            timeout.tv_usec = ((tm % 1000) * 1000) as libc::suseconds_t;
-            &timeout as *libc::timeval
+                // The actual timeout listed in the requests array is an
+                // absolute date, so here we translate the absolute time to a
+                // relative time.
+                let tm = target - now;
+                timeout.tv_sec = (tm / 1000) as libc::time_t;
+                timeout.tv_usec = ((tm % 1000) * 1000) as libc::suseconds_t;
+                &timeout as *libc::timeval
+            }
         };
 
         imp::fd_set(&mut set, input);

branches/try2/src/libnum/bigint.rs

@@ -495,23 +495,24 @@ impl ToPrimitive for BigUint {
     #[cfg(target_word_size = "32")]
     #[inline]
     fn to_u64(&self) -> Option<u64> {
-        match self.data.len() {
-            0 => Some(0),
-            1 => Some(self.data[0] as u64),
-            2 => {
-                Some(BigDigit::to_uint(self.data[1], self.data[0]) as u64)
+        match self.data {
+            [] => {
+                Some(0)
             }
-            3 => {
-                let n_lo = BigDigit::to_uint(self.data[1], self.data[0]) as
-                    u64;
-                let n_hi = self.data[2] as u64;
+            [n0] => {
+                Some(n0 as u64)
+            }
+            [n0, n1] => {
+                Some(BigDigit::to_uint(n1, n0) as u64)
+            }
+            [n0, n1, n2] => {
+                let n_lo = BigDigit::to_uint(n1, n0) as u64;
+                let n_hi = n2 as u64;
                 Some((n_hi << 32) + n_lo)
             }
-            4 => {
-                let n_lo = BigDigit::to_uint(self.data[1], self.data[0])
-                    as u64;
-                let n_hi = BigDigit::to_uint(self.data[3], self.data[2])
-                    as u64;
+            [n0, n1, n2, n3] => {
+                let n_lo = BigDigit::to_uint(n1, n0) as u64;
+                let n_hi = BigDigit::to_uint(n3, n2) as u64;
                 Some((n_hi << 32) + n_lo)
             }
             _ => None
@@ -521,10 +522,16 @@ impl ToPrimitive for BigUint {
     #[cfg(target_word_size = "64")]
     #[inline]
     fn to_u64(&self) -> Option<u64> {
-        match self.data.len() {
-            0 => Some(0),
-            1 => Some(self.data[0] as u64),
-            2 => Some(BigDigit::to_uint(self.data[1], self.data[0]) as u64),
+        match self.data {
+            [] => {
+                Some(0)
+            }
+            [n0] => {
+                Some(n0 as u64)
+            }
+            [n0, n1] => {
+                Some(BigDigit::to_uint(n1, n0) as u64)
+            }
             _ => None
         }
     }
@@ -1254,7 +1261,7 @@ impl FromStrRadix for BigInt {
     }
 }
 
-trait RandBigInt {
+pub trait RandBigInt {
     /// Generate a random `BigUint` of the given bit size.
     fn gen_biguint(&mut self, bit_size: uint) -> BigUint;
 

branches/try2/src/librustc/back/archive.rs

@@ -173,7 +173,6 @@ impl Archive {
             if_ok!(fs::rename(file, &new_filename));
             inputs.push(new_filename);
         }
-        if inputs.len() == 0 { return Ok(()) }
 
         // Finally, add all the renamed files to this archive
         let mut args = ~[&self.dst];