Remove the deprecated Duration::span

… so that Duration can be moved into libcore.

The removal will hit stable in 1.7 at the soonest,
while 1.6 already has the deprecation warning.

Author: SimonSapin

src/libstd/time/duration.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use ops::{Add, Sub, Mul, Div};
-use time::Instant;
 
 const NANOS_PER_SEC: u32 = 1_000_000_000;
 const NANOS_PER_MILLI: u32 = 1_000_000;
@@ -59,21 +58,6 @@ impl Duration {
         Duration { secs: secs, nanos: nanos }
     }
 
-    /// Runs a closure, returning the duration of time it took to run the
-    /// closure.
-    #[unstable(feature = "duration_span",
-               reason = "unsure if this is the right API or whether it should \
-                         wait for a more general \"moment in time\" \
-                         abstraction",
-               issue = "27799")]
-    #[rustc_deprecated(reason = "use std::time::Instant instead",
-                       since = "1.6.0")]
-    pub fn span<F>(f: F) -> Duration where F: FnOnce() {
-        let start = Instant::now();
-        f();
-        start.elapsed()
-    }
-
     /// Creates a new `Duration` from the specified number of seconds.
     #[stable(feature = "duration", since = "1.3.0")]
     pub fn from_secs(secs: u64) -> Duration {

src/test/bench/core-map.rs

@@ -8,15 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(std_misc, rand, duration, duration_span)]
+#![feature(std_misc, rand, time2)]
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::env;
 use std::__rand::{Rng, thread_rng};
-use std::time::Duration;
+use std::time::Instant;
 
-fn timed<F>(label: &str, f: F) where F: FnMut() {
-    println!("  {}: {:?}", label, Duration::span(f));
+fn timed<F>(label: &str, mut f: F) where F: FnMut() {
+    let start = Instant::now();
+    f();
+    println!("  {}: {:?}", label, start.elapsed());
 }
 
 trait MutableMap {

src/test/bench/core-set.rs

@@ -10,7 +10,7 @@
 
 // ignore-pretty very bad with line comments
 
-#![feature(unboxed_closures, rand, std_misc, collections, duration, duration_span)]
+#![feature(unboxed_closures, rand, std_misc, collections, time2)]
 #![feature(bitset)]
 
 extern crate collections;
@@ -20,7 +20,7 @@ use std::collections::BTreeSet;
 use std::collections::HashSet;
 use std::hash::Hash;
 use std::env;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 struct Results {
     sequential_ints: Duration,
@@ -33,7 +33,9 @@ struct Results {
 }
 
 fn timed<F>(result: &mut Duration, op: F) where F: FnOnce() {
-    *result = Duration::span(op);
+    let start = Instant::now();
+    op();
+    *result = start.elapsed();
 }
 
 trait MutableSet<T> {

src/test/bench/core-std.rs

@@ -10,13 +10,13 @@
 
 // Microbenchmarks for various functions in std and extra
 
-#![feature(rand, vec_push_all, duration, duration_span)]
+#![feature(rand, vec_push_all, time2)]
 
 use std::mem::swap;
 use std::env;
 use std::__rand::{thread_rng, Rng};
 use std::str;
-use std::time::Duration;
+use std::time::Instant;
 
 fn main() {
     let argv: Vec<String> = env::args().collect();
@@ -49,7 +49,9 @@ fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() {
         return
     }
 
-    let dur = Duration::span(test);
+    let start = Instant::now();
+    test();
+    let dur = start.elapsed();
 
     println!("{}:\t\t{:?}", name, dur);
 }

src/test/bench/msgsend-pipes-shared.rs

@@ -18,12 +18,12 @@
 // different scalability characteristics compared to the select
 // version.
 
-#![feature(duration, duration_span)]
+#![feature(time2)]
 
 use std::sync::mpsc::{channel, Sender, Receiver};
 use std::env;
 use std::thread;
-use std::time::Duration;
+use std::time::Instant;
 
 fn move_out<T>(_x: T) {}
 
@@ -60,7 +60,8 @@ fn run(args: &[String]) {
     let num_bytes = 100;
     let mut result = None;
     let mut p = Some((to_child, to_parent, from_parent));
-    let dur = Duration::span(|| {
+    let start = Instant::now();
+    {
         let (to_child, to_parent, from_parent) = p.take().unwrap();
         let mut worker_results = Vec::new();
         for _ in 0..workers {
@@ -85,7 +86,8 @@ fn run(args: &[String]) {
         to_child.send(request::stop).unwrap();
         move_out(to_child);
         result = Some(from_child.recv().unwrap());
-    });
+    }
+    let dur = start.elapsed();
     let result = result.unwrap();
     print!("Count is {}\n", result);
     print!("Test took {:?}\n", dur);

src/test/bench/msgsend-pipes.rs

@@ -14,12 +14,12 @@
 //
 // I *think* it's the same, more or less.
 
-#![feature(duration, duration_span)]
+#![feature(time2)]
 
 use std::sync::mpsc::{channel, Sender, Receiver};
 use std::env;
 use std::thread;
-use std::time::Duration;
+use std::time::Instant;
 
 enum request {
     get_count,
@@ -53,7 +53,8 @@ fn run(args: &[String]) {
     let num_bytes = 100;
     let mut result = None;
     let mut to_parent = Some(to_parent);
-    let dur = Duration::span(|| {
+    let start = Instant::now();
+    {
         let to_parent = to_parent.take().unwrap();
         let mut worker_results = Vec::new();
         let from_parent = if workers == 1 {
@@ -92,7 +93,8 @@ fn run(args: &[String]) {
         //to_child.send(stop);
         //move_out(to_child);
         result = Some(from_child.recv().unwrap());
-    });
+    }
+    let dur = start.elapsed();
     let result = result.unwrap();
     print!("Count is {}\n", result);
     print!("Test took {:?}\n", dur);

src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -17,11 +17,11 @@
 
 // no-pretty-expanded FIXME #15189
 
-#![feature(duration_span)]
+#![feature(time2)]
 
 use std::env;
 use std::sync::{Arc, Mutex, Condvar};
-use std::time::Duration;
+use std::time::Instant;
 use std::thread;
 
 // A poor man's pipe.
@@ -80,7 +80,8 @@ fn main() {
     let (num_chan, num_port) = init();
 
     let mut p = Some((num_chan, num_port));
-    let dur = Duration::span(|| {
+    let start = Instant::now();
+    {
         let (mut num_chan, num_port) = p.take().unwrap();
 
         // create the ring
@@ -104,7 +105,8 @@ fn main() {
         for f in futures {
             f.join().unwrap()
         }
-    });
+    }
+    let dur = start.elapsed();
 
     // all done, report stats.
     let num_msgs = num_tasks * msg_per_task;

src/test/bench/shootout-pfib.rs

@@ -18,15 +18,15 @@
 
 */
 
-#![feature(duration, duration_span, rustc_private)]
+#![feature(time2, rustc_private)]
 
 extern crate getopts;
 
 use std::sync::mpsc::{channel, Sender};
 use std::env;
 use std::result::Result::{Ok, Err};
 use std::thread;
-use std::time::Duration;
+use std::time::Instant;
 
 fn fib(n: isize) -> isize {
     fn pfib(tx: &Sender<isize>, n: isize) {
@@ -110,9 +110,9 @@ fn main() {
 
         for n in 1..max + 1 {
             for _ in 0..num_trials {
-                let mut fibn = None;
-                let dur = Duration::span(|| fibn = Some(fib(n)));
-                let fibn = fibn.unwrap();
+                let start = Instant::now();
+                let fibn = fib(n);
+                let dur = start.elapsed();
 
                 println!("{}\t{}\t{:?}", n, fibn, dur);
             }

src/test/bench/task-perf-alloc-unwind.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(box_syntax, duration, duration_span, vec_push_all)]
+#![feature(box_syntax, time2, vec_push_all)]
 
 use std::env;
 use std::thread;
-use std::time::Duration;
+use std::time::Instant;
 
 #[derive(Clone)]
 enum List<T> {
@@ -31,12 +31,11 @@ fn main() {
 
 fn run(repeat: isize, depth: isize) {
     for _ in 0..repeat {
-        let dur = Duration::span(|| {
-            let _ = thread::spawn(move|| {
-                recurse_or_panic(depth, None)
-            }).join();
-        });
-        println!("iter: {:?}", dur);
+        let start = Instant::now();
+        let _ = thread::spawn(move|| {
+            recurse_or_panic(depth, None)
+        }).join();
+        println!("iter: {:?}", start.elapsed());
     }
 }