---

yaml
---
r: 64903
b: refs/heads/snap-stage3
c: 428ea7d
h: refs/heads/master
i:
  64901: dd985b6
  64899: 7c9ccfb
  64895: 1479eb7
v: v3

Author: sanxiyn

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8b7e241e02bb9f82d7b931033afde477d03ff4f2
+refs/heads/snap-stage3: 428ea7d7ce39c46a57eaf09b10d9a3d4a488e6e8
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/tests.mk

@@ -34,16 +34,12 @@ ifdef CHECK_XFAILS
   TESTARGS += --ignored
 endif
 
-TEST_BENCH = --bench
+CTEST_BENCH = --bench
 
 # Arguments to the cfail/rfail/rpass/bench tests
 ifdef CFG_VALGRIND
   CTEST_RUNTOOL = --runtool "$(CFG_VALGRIND)"
-  TEST_BENCH =
-endif
-
-ifdef NO_BENCH
-  TEST_BENCH =
+  CTEST_BENCH =
 endif
 
 # Arguments to the perf tests
@@ -73,12 +69,12 @@ TEST_RATCHET_NOISE_PERCENT=10.0
 # Whether to ratchet or merely save benchmarks
 ifdef CFG_RATCHET_BENCH
 CRATE_TEST_BENCH_ARGS=\
-  --test $(TEST_BENCH) \
+  --test $(CTEST_BENCH) \
   --ratchet-metrics $(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4)) \
   --ratchet-noise-percent $(TEST_RATCHET_NOISE_PERCENT)
 else
 CRATE_TEST_BENCH_ARGS=\
-  --test $(TEST_BENCH) \
+  --test $(CTEST_BENCH) \
   --save-metrics $(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4))
 endif
 

branches/snap-stage3/src/libextra/arc.rs

@@ -136,7 +136,7 @@ impl<T:Freeze+Send> Arc<T> {
      */
     pub fn unwrap(self) -> T {
         let Arc { x: x } = self;
-        x.unwrap()
+        unsafe { x.unwrap() }
     }
 }
 
@@ -250,7 +250,7 @@ impl<T:Send> MutexArc<T> {
      */
     pub fn unwrap(self) -> T {
         let MutexArc { x: x } = self;
-        let inner = x.unwrap();
+        let inner = unsafe { x.unwrap() };
         let MutexArcInner { failed: failed, data: data, _ } = inner;
         if failed {
             fail!(~"Can't unwrap poisoned MutexArc - another task failed inside!");
@@ -469,7 +469,7 @@ impl<T:Freeze + Send> RWArc<T> {
      */
     pub fn unwrap(self) -> T {
         let RWArc { x: x, _ } = self;
-        let inner = x.unwrap();
+        let inner = unsafe { x.unwrap() };
         let RWArcInner { failed: failed, data: data, _ } = inner;
         if failed {
             fail!(~"Can't unwrap poisoned RWArc - another task failed inside!")

branches/snap-stage3/src/libextra/getopts.rs

@@ -140,9 +140,7 @@ pub fn optflag(name: &str) -> Opt {
     return Opt {name: mkname(name), hasarg: No, occur: Optional};
 }
 
-/** Create an option that is optional, does not take an argument,
-  * and may occur multiple times.
-  */
+/// Create an option that is optional and does not take an argument
 pub fn optflagmulti(name: &str) -> Opt {
     return Opt {name: mkname(name), hasarg: No, occur: Multi};
 }
@@ -371,14 +369,7 @@ fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
     };
 }
 
-fn opt_val(mm: &Matches, nm: &str) -> Option<Optval> {
-    let vals = opt_vals(mm, nm);
-    if (vals.is_empty()) {
-        None
-    } else {
-        Some(opt_vals(mm, nm)[0].clone())
-    }
-}
+fn opt_val(mm: &Matches, nm: &str) -> Optval { opt_vals(mm, nm)[0].clone() }
 
 /// Returns true if an option was matched
 pub fn opt_present(mm: &Matches, nm: &str) -> bool {
@@ -409,10 +400,7 @@ pub fn opts_present(mm: &Matches, names: &[~str]) -> bool {
  * argument
  */
 pub fn opt_str(mm: &Matches, nm: &str) -> ~str {
-    return match opt_val(mm, nm) {
-        Some(Val(s)) => s,
-        _ => fail!()
-    };
+    return match opt_val(mm, nm) { Val(s) => s, _ => fail!() };
 }
 
 /**
@@ -424,7 +412,7 @@ pub fn opt_str(mm: &Matches, nm: &str) -> ~str {
 pub fn opts_str(mm: &Matches, names: &[~str]) -> ~str {
     for names.iter().advance |nm| {
         match opt_val(mm, *nm) {
-          Some(Val(ref s)) => return (*s).clone(),
+          Val(ref s) => return (*s).clone(),
           _ => ()
         }
     }
@@ -1330,41 +1318,24 @@ mod tests {
 
     #[test]
     fn test_multi() {
+        let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
         let opts = ~[optopt("e"), optopt("encrypt"), optopt("f")];
-
-        let args_single = ~[~"-e", ~"foo"];
-        let matches_single = &match getopts(args_single, opts) {
-          result::Ok(m) => m,
-          result::Err(_) => fail!()
-        };
-        assert!(opts_present(matches_single, [~"e"]));
-        assert!(opts_present(matches_single, [~"encrypt", ~"e"]));
-        assert!(opts_present(matches_single, [~"e", ~"encrypt"]));
-        assert!(!opts_present(matches_single, [~"encrypt"]));
-        assert!(!opts_present(matches_single, [~"thing"]));
-        assert!(!opts_present(matches_single, []));
-
-        assert_eq!(opts_str(matches_single, [~"e"]), ~"foo");
-        assert_eq!(opts_str(matches_single, [~"e", ~"encrypt"]), ~"foo");
-        assert_eq!(opts_str(matches_single, [~"encrypt", ~"e"]), ~"foo");
-
-        let args_both = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
-        let matches_both = &match getopts(args_both, opts) {
+        let matches = &match getopts(args, opts) {
           result::Ok(m) => m,
           result::Err(_) => fail!()
         };
-        assert!(opts_present(matches_both, [~"e"]));
-        assert!(opts_present(matches_both, [~"encrypt"]));
-        assert!(opts_present(matches_both, [~"encrypt", ~"e"]));
-        assert!(opts_present(matches_both, [~"e", ~"encrypt"]));
-        assert!(!opts_present(matches_both, [~"f"]));
-        assert!(!opts_present(matches_both, [~"thing"]));
-        assert!(!opts_present(matches_both, []));
-
-        assert_eq!(opts_str(matches_both, [~"e"]), ~"foo");
-        assert_eq!(opts_str(matches_both, [~"encrypt"]), ~"foo");
-        assert_eq!(opts_str(matches_both, [~"e", ~"encrypt"]), ~"foo");
-        assert_eq!(opts_str(matches_both, [~"encrypt", ~"e"]), ~"foo");
+        assert!(opts_present(matches, [~"e"]));
+        assert!(opts_present(matches, [~"encrypt"]));
+        assert!(opts_present(matches, [~"encrypt", ~"e"]));
+        assert!(opts_present(matches, [~"e", ~"encrypt"]));
+        assert!(!opts_present(matches, [~"f"]));
+        assert!(!opts_present(matches, [~"thing"]));
+        assert!(!opts_present(matches, []));
+
+        assert_eq!(opts_str(matches, [~"e"]), ~"foo");
+        assert_eq!(opts_str(matches, [~"encrypt"]), ~"foo");
+        assert_eq!(opts_str(matches, [~"e", ~"encrypt"]), ~"foo");
+        assert_eq!(opts_str(matches, [~"encrypt", ~"e"]), ~"foo");
     }
 
     #[test]

branches/snap-stage3/src/libextra/sync.rs

@@ -130,9 +130,11 @@ impl<Q:Send> Sem<Q> {
 impl Sem<()> {
     pub fn access<U>(&self, blk: &fn() -> U) -> U {
         let mut release = None;
-        do task::unkillable {
-            self.acquire();
-            release = Some(SemRelease(self));
+        unsafe {
+            do task::unkillable {
+                self.acquire();
+                release = Some(SemRelease(self));
+            }
         }
         blk()
     }
@@ -151,9 +153,11 @@ impl Sem<~[WaitQueue]> {
 
     pub fn access_waitqueue<U>(&self, blk: &fn() -> U) -> U {
         let mut release = None;
-        do task::unkillable {
-            self.acquire();
-            release = Some(SemAndSignalRelease(self));
+        unsafe {
+            do task::unkillable {
+                self.acquire();
+                release = Some(SemAndSignalRelease(self));
+            }
         }
         blk()
     }
@@ -290,15 +294,17 @@ impl<'self> Condvar<'self> {
         #[unsafe_destructor]
         impl<'self> Drop for CondvarReacquire<'self> {
             fn drop(&self) {
-                // Needs to succeed, instead of itself dying.
-                do task::unkillable {
-                    match self.order {
-                        Just(lock) => do lock.access {
-                            self.sem.acquire();
-                        },
-                        Nothing => {
-                            self.sem.acquire();
-                        },
+                unsafe {
+                    // Needs to succeed, instead of itself dying.
+                    do task::unkillable {
+                        match self.order {
+                            Just(lock) => do lock.access {
+                                self.sem.acquire();
+                            },
+                            Nothing => {
+                                self.sem.acquire();
+                            },
+                        }
                     }
                 }
             }
@@ -638,12 +644,14 @@ impl RWLock {
         // Implementation slightly different from the slicker 'write's above.
         // The exit path is conditional on whether the caller downgrades.
         let mut _release = None;
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            (&self.access_lock).acquire();
-            (&self.order_lock).release();
+        unsafe {
+            do task::unkillable {
+                (&self.order_lock).acquire();
+                (&self.access_lock).acquire();
+                (&self.order_lock).release();
+            }
+            _release = Some(RWLockReleaseDowngrade(self));
         }
-        _release = Some(RWLockReleaseDowngrade(self));
         blk(RWLockWriteMode { lock: self })
     }
 
@@ -882,7 +890,7 @@ mod tests {
     fn test_sem_runtime_friendly_blocking() {
         // Force the runtime to schedule two threads on the same sched_loop.
         // When one blocks, it should schedule the other one.
-        do task::spawn_sched(task::SingleThreaded) {
+        do task::spawn_sched(task::ManualThreads(1)) {
             let s = ~Semaphore::new(1);
             let s2 = ~s.clone();
             let (p,c) = comm::stream();

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

@@ -587,7 +587,7 @@ impl GenericPath for PosixPath {
     }
 
     fn with_filename(&self, f: &str) -> PosixPath {
-        assert!(!f.iter().all(posix::is_sep));
+        assert!(! f.iter().all(windows::is_sep));
         self.dir_path().push(f)
     }
 
@@ -648,7 +648,7 @@ impl GenericPath for PosixPath {
     fn push_many<S: Str>(&self, cs: &[S]) -> PosixPath {
         let mut v = self.components.clone();
         for cs.iter().advance |e| {
-            for e.as_slice().split_iter(posix::is_sep).advance |s| {
+            for e.as_slice().split_iter(windows::is_sep).advance |s| {
                 if !s.is_empty() {
                     v.push(s.to_owned())
                 }
@@ -662,7 +662,7 @@ impl GenericPath for PosixPath {
 
     fn push(&self, s: &str) -> PosixPath {
         let mut v = self.components.clone();
-        for s.split_iter(posix::is_sep).advance |s| {
+        for s.split_iter(windows::is_sep).advance |s| {
             if !s.is_empty() {
                 v.push(s.to_owned())
             }
@@ -1001,17 +1001,7 @@ pub fn normalize(components: &[~str]) -> ~[~str] {
     cs
 }
 
-// Various posix helpers.
-pub mod posix {
-
-    #[inline]
-    pub fn is_sep(u: char) -> bool {
-        u == '/'
-    }
-
-}
-
-// Various windows helpers.
+// Various windows helpers, and tests for the impl.
 pub mod windows {
     use libc;
     use option::{None, Option, Some};
@@ -1149,14 +1139,6 @@ mod tests {
 
     }
 
-    #[test]
-    fn test_posix_push_with_backslash() {
-        let a = PosixPath("/aaa/bbb");
-        let b = a.push("x\\y"); // \ is not a file separator for posix paths
-        assert_eq!(a.components.len(), 2);
-        assert_eq!(b.components.len(), 3);
-    }
-
     #[test]
     fn test_normalize() {
         fn t(wp: &PosixPath, s: &str) {