---

yaml
---
r: 47087
b: refs/heads/try
c: ec161ed
h: refs/heads/master
i:
  47085: e2386f7
  47083: acad414
  47079: c6422cf
  47071: 97ea808
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: c8d8f6cfec50cad6b35e3b5fc604abc01a26143e
+refs/heads/try: ec161edc16b0b3b3bdbd425e0bb085fc7fae15d4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/os.rs

@@ -565,13 +565,17 @@ pub fn path_exists(p: &Path) -> bool {
  *
  * If the given path is relative, return it prepended with the current working
  * directory. If the given path is already an absolute path, return it
- * as is.  This is a shortcut for calling os::getcwd().unsafe_join(p)
+ * as is.
  */
 // NB: this is here rather than in path because it is a form of environment
 // querying; what it does depends on the process working directory, not just
 // the input paths.
 pub fn make_absolute(p: &Path) -> Path {
-    getcwd().unsafe_join(p)
+    if p.is_absolute {
+        copy *p
+    } else {
+        getcwd().push_many(p.components)
+    }
 }
 
 

branches/try/src/libcore/path.rs

@@ -64,8 +64,6 @@ pub trait GenericPath {
     pure fn push_many((&[~str])) -> Self;
     pure fn pop() -> Self;
 
-    pure fn unsafe_join((&Self)) -> Self;
-
     pure fn normalize() -> Self;
 }
 
@@ -487,15 +485,6 @@ impl GenericPath for PosixPath {
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &PosixPath) -> PosixPath {
-        if other.is_absolute {
-            PosixPath { is_absolute: true,
-                        components: copy other.components }
-        } else {
-            self.push_rel(other)
-        }
-    }
-
     pure fn push_many(cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
@@ -696,25 +685,6 @@ impl GenericPath for WindowsPath {
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &WindowsPath) -> WindowsPath {
-        if !other.is_absolute {
-            self.push_rel(other)
-        } else {
-            WindowsPath {
-                host: match other.host {
-                    None => copy self.host,
-                    Some(copy x) => Some(x)
-                },
-                device: match other.device {
-                    None => copy self.device,
-                    Some(copy x) => Some(x)
-                },
-                is_absolute: true,
-                components: copy other.components
-            }
-        }
-    }
-
     pure fn push_many(cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {

branches/try/src/libcore/vec.rs

@@ -1865,6 +1865,7 @@ pub trait OwnedVector<T> {
     fn consume(self, f: fn(uint, v: T));
     fn filter(self, f: fn(t: &T) -> bool) -> ~[T];
     fn partition(self, f: pure fn(&T) -> bool) -> (~[T], ~[T]);
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
 }
 
 impl<T> OwnedVector<T> for ~[T] {
@@ -1936,6 +1937,11 @@ impl<T> OwnedVector<T> for ~[T] {
     fn partition(self, f: fn(&T) -> bool) -> (~[T], ~[T]) {
         partition(self, f)
     }
+
+    #[inline]
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
+        grow_fn(self, n, op);
+    }
 }
 
 impl<T> Mutable for ~[T] {
@@ -1946,7 +1952,6 @@ impl<T> Mutable for ~[T] {
 pub trait OwnedCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
     fn grow(&mut self, n: uint, initval: &T);
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
     fn grow_set(&mut self, index: uint, initval: &T, val: T);
 }
 
@@ -1961,11 +1966,6 @@ impl<T: Copy> OwnedCopyableVector<T> for ~[T] {
         grow(self, n, initval);
     }
 
-    #[inline]
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
-        grow_fn(self, n, op);
-    }
-
     #[inline]
     fn grow_set(&mut self, index: uint, initval: &T, val: T) {
         grow_set(self, index, initval, val);

branches/try/src/libstd/deque.rs

@@ -100,7 +100,7 @@ fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
     assert nelts == elts.len();
     let mut rv = ~[];
 
-    do vec::grow_fn(&mut rv, nelts + 1) |i| {
+    do rv.grow_fn(nelts + 1) |i| {
         let mut element = None;
         element <-> elts[(lo + i) % nelts];
         element