---

yaml
---
r: 57879
b: refs/heads/incoming
c: e4ca2da
h: refs/heads/master
i:
  57877: 287cd80
  57875: ff6d965
  57871: 80b5f60
v: v3

Author: gifnksm

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: bf67eb2362b7d0f37012f2d6dac604c3bbacd2c6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: d045ce7b87af0fb0730ccf5291c11d28a5382254
+refs/heads/incoming: e4ca2da42072fccd16aefdc4f2090b0489e8293c
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/os.rs

@@ -643,22 +643,20 @@ pub fn make_dir(p: &Path, mode: c_int) -> bool {
 /// Returns true iff creation
 /// succeeded. Also creates all intermediate subdirectories
 /// if they don't already exist, giving all of them the same mode.
-
-// tjc: if directory exists but with different permissions,
-// should we return false?
 pub fn mkdir_recursive(p: &Path, mode: c_int) -> bool {
     if path_is_dir(p) {
         return true;
     }
-    else if p.components.is_empty() {
-        return false;
-    }
-    else if p.components.len() == 1 {
+    let parent = p.dir_path();
+    debug!("mkdir_recursive: parent = %s",
+           parent.to_str());
+    if parent.to_str() == ~"."
+        || parent.to_str() == ~"/" { // !!!
         // No parent directories to create
-        path_is_dir(p) || make_dir(p, mode)
+        path_is_dir(&parent) && make_dir(p, mode)
     }
     else {
-        mkdir_recursive(&p.pop(), mode) && make_dir(p, mode)
+        mkdir_recursive(&parent, mode) && make_dir(p, mode)
     }
 }
 
@@ -1269,8 +1267,6 @@ mod tests {
     use run;
     use str;
     use vec;
-    use libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-
 
     #[test]
     pub fn last_os_error() {
@@ -1494,16 +1490,16 @@ mod tests {
     }
 
     #[test]
-    fn recursive_mkdir_slash() {
-        let path = Path("/");
-        assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-    }
+    fn recursive_mkdir_ok() {
+        use libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 
-    #[test]
-    fn recursive_mkdir_empty() {
-        let path = Path("");
-        assert!(!os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+        let root = os::tmpdir();
+        let path = "xy/z/zy";
+        let nested = root.push(path);
+        assert!(os::mkdir_recursive(&nested,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+        assert!(os::path_is_dir(&root.push("xy")));
+        assert!(os::path_is_dir(&root.push("xy/z")));
+        assert!(os::path_is_dir(&nested));
     }
 
-    // More recursive_mkdir tests are in std::tempfile
 }

branches/incoming/src/libcore/path.rs

@@ -44,71 +44,31 @@ pub fn PosixPath(s: &str) -> PosixPath {
 }
 
 pub trait GenericPath {
-    /// Converts a string to a Path
     fn from_str(&str) -> Self;
 
-    /// Returns the directory component of `self`, as a string
     fn dirname(&self) -> ~str;
-    /// Returns the file component of `self`, as a string option.
-    /// Returns None if `self` names a directory.
     fn filename(&self) -> Option<~str>;
-    /// Returns the stem of the file component of `self`, as a string option.
-    /// The stem is the slice of a filename starting at 0 and ending just before
-    /// the last '.' in the name.
-    /// Returns None if `self` names a directory.
     fn filestem(&self) -> Option<~str>;
-    /// Returns the type of the file component of `self`, as a string option.
-    /// The file type is the slice of a filename starting just after the last
-    /// '.' in the name and ending at the last index in the filename.
-    /// Returns None if `self` names a directory.
     fn filetype(&self) -> Option<~str>;
 
-    /// Returns a new path consisting of `self` with the parent directory component replaced
-    /// with the given string.
     fn with_dirname(&self, (&str)) -> Self;
-    /// Returns a new path consisting of `self` with the file component replaced
-    /// with the given string.
     fn with_filename(&self, (&str)) -> Self;
-    /// Returns a new path consisting of `self` with the file stem replaced
-    /// with the given string.
     fn with_filestem(&self, (&str)) -> Self;
-    /// Returns a new path consisting of `self` with the file type replaced
-    /// with the given string.
     fn with_filetype(&self, (&str)) -> Self;
 
-    /// Returns the directory component of `self`, as a new path.
-    /// If `self` has no parent, returns `self`.
     fn dir_path(&self) -> Self;
-    /// Returns the file component of `self`, as a new path.
-    /// If `self` names a directory, returns the empty path.
     fn file_path(&self) -> Self;
 
-    /// Returns a new Path whose parent directory is `self` and whose
-    /// file component is the given string.
     fn push(&self, (&str)) -> Self;
-    /// Returns a new Path consisting of the given path, made relative to `self`.
     fn push_rel(&self, (&Self)) -> Self;
-    /// Returns a new Path consisting of the path given by the given vector
-    /// of strings, relative to `self`.
     fn push_many(&self, (&[~str])) -> Self;
-    /// Identical to `dir_path` except in the case where `self` has only one
-    /// component. In this case, `pop` returns the empty path.
     fn pop(&self) -> Self;
 
-    /// The same as `push_rel`, except that the directory argument must not
-    /// contain directory separators in any of its components.
     fn unsafe_join(&self, (&Self)) -> Self;
-    /// On Unix, always returns false. On Windows, returns true iff `self`'s
-    /// file stem is one of: `con` `aux` `com1` `com2` `com3` `com4`
-    /// `lpt1` `lpt2` `lpt3` `prn` `nul`
     fn is_restricted(&self) -> bool;
 
-    /// Returns a new path that names the same file as `self`, without containing
-    /// any '.', '..', or empty components. On Windows, uppercases the drive letter
-    /// as well.
     fn normalize(&self) -> Self;
 
-    /// Returns `true` if `self` is an absolute path.
     fn is_absolute(&self) -> bool;
 }
 

branches/incoming/src/libstd/num/bigint.rs

@@ -16,6 +16,9 @@ A BigUint is represented as an array of BigDigits.
 A BigInt is a combination of BigUint and Sign.
 */
 
+#[deny(vecs_implicitly_copyable)];
+#[deny(deprecated_mutable_fields)];
+
 use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use core::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix};
 use core::*;
@@ -355,16 +358,24 @@ impl Integer for BigUint {
                 let mut (d0, d_unit, b_unit) = div_estimate(&m, &b, n);
                 let mut prod = b * d0;
                 while prod > m {
-                    d0   -= d_unit;
-                    prod -= b_unit;
+                    // FIXME(#6050): overloaded operators force moves with generic types
+                    // d0 -= d_unit
+                    d0   = d0 - d_unit;
+                    // FIXME(#6050): overloaded operators force moves with generic types
+                    // prod = prod - b_unit;
+                    prod = prod - b_unit
                 }
                 if d0.is_zero() {
                     n = 2;
                     loop;
                 }
                 n = 1;
-                d += d0;
-                m -= prod;
+                // FIXME(#6102): Assignment operator for BigInt causes ICE
+                // d += d0;
+                d = d + d0;
+                // FIXME(#6102): Assignment operator for BigInt causes ICE
+                // m -= prod;
+                m = m - prod;
             }
             return (d, m);
         }
@@ -411,7 +422,7 @@ impl Integer for BigUint {
     #[inline(always)]
     fn gcd(&self, other: &BigUint) -> BigUint {
         // Use Euclid's algorithm
-        let mut m = *self, n = *other;
+        let mut m = copy *self, n = copy *other;
         while !m.is_zero() {
             let temp = m;
             m = n % temp;
@@ -547,14 +558,18 @@ impl BigUint {
         loop {
             let start = uint::max(end, unit_len) - unit_len;
             match uint::parse_bytes(vec::slice(buf, start, end), radix) {
-                Some(d) => n += BigUint::from_uint(d) * power,
+                // FIXME(#6102): Assignment operator for BigInt causes ICE
+                // Some(d) => n += BigUint::from_uint(d) * power,
+                Some(d) => n = n + BigUint::from_uint(d) * power,
                 None    => return None
             }
             if end <= unit_len {
                 return Some(n);
             }
             end -= unit_len;
-            power *= base_num;
+            // FIXME(#6050): overloaded operators force moves with generic types
+            // power *= base_num;
+            power = power * base_num;
         }
     }
 
@@ -569,15 +584,15 @@ impl BigUint {
     }
 
     #[inline(always)]
-    priv fn shl_unit(self, n_unit: uint) -> BigUint {
-        if n_unit == 0 || self.is_zero() { return self; }
+    priv fn shl_unit(&self, n_unit: uint) -> BigUint {
+        if n_unit == 0 || self.is_zero() { return copy *self; }
 
         return BigUint::new(vec::from_elem(n_unit, 0) + self.data);
     }
 
     #[inline(always)]
-    priv fn shl_bits(self, n_bits: uint) -> BigUint {
-        if n_bits == 0 || self.is_zero() { return self; }
+    priv fn shl_bits(&self, n_bits: uint) -> BigUint {
+        if n_bits == 0 || self.is_zero() { return copy *self; }
 
         let mut carry = 0;
         let shifted = do vec::map(self.data) |elem| {
@@ -592,17 +607,17 @@ impl BigUint {
     }
 
     #[inline(always)]
-    priv fn shr_unit(self, n_unit: uint) -> BigUint {
-        if n_unit == 0 { return self; }
+    priv fn shr_unit(&self, n_unit: uint) -> BigUint {
+        if n_unit == 0 { return copy *self; }
         if self.data.len() < n_unit { return Zero::zero(); }
         return BigUint::from_slice(
             vec::slice(self.data, n_unit, self.data.len())
         );
     }
 
     #[inline(always)]
-    priv fn shr_bits(self, n_bits: uint) -> BigUint {
-        if n_bits == 0 || self.data.is_empty() { return self; }
+    priv fn shr_bits(&self, n_bits: uint) -> BigUint {
+        if n_bits == 0 || self.data.is_empty() { return copy *self; }
 
         let mut borrow = 0;
         let mut shifted = ~[];
@@ -1070,7 +1085,7 @@ pub impl BigInt {
             start = 1;
         }
         return BigUint::parse_bytes(vec::slice(buf, start, buf.len()), radix)
-            .map(|bu| BigInt::from_biguint(sign, *bu));
+            .map_consume(|bu| BigInt::from_biguint(sign, bu));
     }
 
     #[inline(always)]
@@ -1376,10 +1391,10 @@ mod biguint_tests {
             let c = BigUint::from_slice(cVec);
 
             if !a.is_zero() {
-                assert!(c.quot_rem(&a) == (b, Zero::zero()));
+                assert!(c.quot_rem(&a) == (copy b, Zero::zero()));
             }
             if !b.is_zero() {
-                assert!(c.quot_rem(&b) == (a, Zero::zero()));
+                assert!(c.quot_rem(&b) == (copy a, Zero::zero()));
             }
         }
 
@@ -1503,7 +1518,7 @@ mod biguint_tests {
             let &(n, rs) = num_pair;
             for rs.each |str_pair| {
                 let &(radix, str) = str_pair;
-                assert_eq!(Some(n), FromStrRadix::from_str_radix(str, radix));
+                assert_eq!(&n, &FromStrRadix::from_str_radix(str, radix).get());
             }
         }
 
@@ -1517,7 +1532,9 @@ mod biguint_tests {
         fn factor(n: uint) -> BigUint {
             let mut f= One::one::<BigUint>();
             for uint::range(2, n + 1) |i| {
-                f *= BigUint::from_uint(i);
+                // FIXME(#6102): Assignment operator for BigInt causes ICE
+                // f *= BigUint::from_uint(i);
+                f = f * BigUint::from_uint(i);
             }
             return f;
         }

branches/incoming/src/libstd/tempfile.rs

@@ -23,62 +23,9 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
     None
 }
 
-#[cfg(test)]
-mod tests {
-    use tempfile::mkdtemp;
-    use tempfile;
-
-    #[test]
-    fn test_mkdtemp() {
-        let p = mkdtemp(&Path("."), "foobar").unwrap();
-        os::remove_dir(&p);
-        assert!(str::ends_with(p.to_str(), "foobar"));
-    }
-
-    // Ideally these would be in core::os but then core would need
-    // to depend on std
-    #[test]
-    fn recursive_mkdir_rel() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
-
-        let root = mkdtemp(&os::tmpdir(), "temp").expect("recursive_mkdir_rel");
-        os::change_dir(&root);
-        let path = Path("frob");
-        assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
-        assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
-    }
-
-    #[test]
-    fn recursive_mkdir_dot() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
-
-        let dot = Path(".");
-        assert!(os::mkdir_recursive(&dot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        let dotdot = Path("..");
-        assert!(os::mkdir_recursive(&dotdot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-    }
-
-    #[test]
-    fn recursive_mkdir_rel_2() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
-
-        let root = mkdtemp(&os::tmpdir(), "temp").expect("recursive_mkdir_rel_2");
-        os::change_dir(&root);
-        let path = Path("./frob/baz");
-        debug!("...Making: %s in cwd %s", path.to_str(), os::getcwd().to_str());
-        assert!(os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path));
-        assert!(os::path_is_dir(&path.pop()));
-        let path2 = Path("quux/blat");
-        debug!("Making: %s in cwd %s", path2.to_str(), os::getcwd().to_str());
-        assert!(os::mkdir_recursive(&path2, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
-        assert!(os::path_is_dir(&path2));
-        assert!(os::path_is_dir(&path2.pop()));
-    }
-
-}
+#[test]
+fn test_mkdtemp() {
+    let p = mkdtemp(&Path("."), "foobar").unwrap();
+    os::remove_dir(&p);
+    assert!(str::ends_with(p.to_str(), "foobar"));
+}