Update Tokio to Rust 2018 (#1082)

tokio/examples/blocking.rs

@@ -9,11 +9,11 @@
 //! Note how non-blocking threads are executed before blocking threads finish
 //! their task.
 
-extern crate tokio;
-extern crate tokio_threadpool;
+#![deny(warnings, rust_2018_idioms)]
 
 use std::thread;
 use std::time::Duration;
+use tokio;
 use tokio::prelude::*;
 use tokio::runtime::Builder;
 use tokio_threadpool::blocking;

tokio/examples/chat-combinator-current-thread.rs

@@ -24,24 +24,21 @@
 //! connected clients they'll all join the same room and see everyone else's
 //! messages.
 
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-use tokio::runtime::current_thread::{Runtime, TaskExecutor};
+#![deny(warnings, rust_2018_idioms)]
 
+use futures;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::env;
 use std::io::BufReader;
 use std::iter;
 use std::rc::Rc;
+use tokio::io;
+use tokio::net::TcpListener;
+use tokio::prelude::*;
+use tokio::runtime::current_thread::{Runtime, TaskExecutor};
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut runtime = Runtime::new().unwrap();
 
     // Create the TCP listener we'll accept connections on.

tokio/examples/chat-combinator.rs

@@ -19,22 +19,20 @@
 //! connected clients they'll all join the same room and see everyone else's
 //! messages.
 
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
+#![deny(warnings, rust_2018_idioms)]
 
+use futures;
 use std::collections::HashMap;
 use std::env;
 use std::io::BufReader;
 use std::iter;
 use std::sync::{Arc, Mutex};
+use tokio;
+use tokio::io;
+use tokio::net::TcpListener;
+use tokio::prelude::*;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create the TCP listener we'll accept connections on.
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse()?;

tokio/examples/chat.rs

@@ -24,23 +24,19 @@
 //! connected clients they'll all join the same room and see everyone else's
 //! messages.
 
-#![deny(warnings)]
-
-extern crate tokio;
-#[macro_use]
-extern crate futures;
-extern crate bytes;
+#![deny(warnings, rust_2018_idioms)]
 
 use bytes::{BufMut, Bytes, BytesMut};
 use futures::future::{self, Either};
 use futures::sync::mpsc;
-use tokio::io;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
-
+use futures::try_ready;
 use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
+use tokio;
+use tokio::io;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::prelude::*;
 
 /// Shorthand for the transmit half of the message channel.
 type Tx = mpsc::UnboundedSender<Bytes>;
@@ -422,7 +418,7 @@ fn process(socket: TcpStream, state: Arc<Mutex<Shared>>) {
     tokio::spawn(connection);
 }
 
-pub fn main() -> Result<(), Box<std::error::Error>> {
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create the shared state. This is how all the peers communicate.
     //
     // The server task will hold a handle to this. For every new client, the

tokio/examples/connect.rs

@@ -14,22 +14,17 @@
 //! this repository! Many of them recommend running this as a simple "hook up
 //! stdin/stdout to a server" to get up and running.
 
-#![deny(warnings)]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
+#![deny(warnings, rust_2018_idioms)]
 
+use futures::sync::mpsc;
 use std::env;
 use std::io::{self, Read, Write};
 use std::net::SocketAddr;
 use std::thread;
-
-use futures::sync::mpsc;
+use tokio;
 use tokio::prelude::*;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Determine if we're going to run in TCP or UDP mode
     let mut args = env::args().skip(1).collect::<Vec<_>>();
     let tcp = match args.iter().position(|a| a == "--udp") {
@@ -124,8 +119,8 @@ mod tcp {
     use tokio::net::TcpStream;
     use tokio::prelude::*;
 
+    use crate::codec::Bytes;
     use bytes::BytesMut;
-    use codec::Bytes;
 
     use std::error::Error;
     use std::io;
@@ -133,8 +128,8 @@ mod tcp {
 
     pub fn connect(
         addr: &SocketAddr,
-        stdin: Box<Stream<Item = Vec<u8>, Error = io::Error> + Send>,
-    ) -> Result<Box<Stream<Item = BytesMut, Error = io::Error> + Send>, Box<Error>> {
+        stdin: Box<dyn Stream<Item = Vec<u8>, Error = io::Error> + Send>,
+    ) -> Result<Box<dyn Stream<Item = BytesMut, Error = io::Error> + Send>, Box<dyn Error>> {
         let tcp = TcpStream::connect(addr);
 
         // After the TCP connection has been established, we set up our client
@@ -181,12 +176,12 @@ mod udp {
     use tokio::net::{UdpFramed, UdpSocket};
     use tokio::prelude::*;
 
-    use codec::Bytes;
+    use crate::codec::Bytes;
 
     pub fn connect(
         &addr: &SocketAddr,
-        stdin: Box<Stream<Item = Vec<u8>, Error = io::Error> + Send>,
-    ) -> Result<Box<Stream<Item = BytesMut, Error = io::Error> + Send>, Box<Error>> {
+        stdin: Box<dyn Stream<Item = Vec<u8>, Error = io::Error> + Send>,
+    ) -> Result<Box<dyn Stream<Item = BytesMut, Error = io::Error> + Send>, Box<dyn Error>> {
         // We'll bind our UDP socket to a local IP/port, but for now we
         // basically let the OS pick both of those.
         let addr_to_bind = if addr.ip().is_ipv4() {

tokio/examples/echo-udp.rs

@@ -10,15 +10,12 @@
 //!
 //! Each line you type in to the `nc` terminal should be echo'd back to you!
 
-#![deny(warnings)]
-
-#[macro_use]
-extern crate futures;
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
+use futures::try_ready;
 use std::net::SocketAddr;
 use std::{env, io};
-
+use tokio;
 use tokio::net::UdpSocket;
 use tokio::prelude::*;
 
@@ -50,7 +47,7 @@ impl Future for Server {
     }
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse::<SocketAddr>()?;
 

tokio/examples/echo.rs

@@ -19,18 +19,16 @@
 //! you! If you open up multiple terminals running the `connect` example you
 //! should be able to see them all make progress simultaneously.
 
-#![deny(warnings)]
-
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
+use std::env;
+use std::net::SocketAddr;
+use tokio;
 use tokio::io;
 use tokio::net::TcpListener;
 use tokio::prelude::*;
 
-use std::env;
-use std::net::SocketAddr;
-
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Allow passing an address to listen on as the first argument of this
     // program, but otherwise we'll just set up our TCP listener on
     // 127.0.0.1:8080 for connections.

tokio/examples/hello_world.rs

@@ -11,15 +11,14 @@
 //!
 //!     cargo run --example hello_world
 
-#![deny(warnings)]
-
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
+use tokio;
 use tokio::io;
 use tokio::net::TcpStream;
 use tokio::prelude::*;
 
-pub fn main() -> Result<(), Box<std::error::Error>> {
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     let addr = "127.0.0.1:6142".parse()?;
 
     // Open a TCP stream to the socket address.

tokio/examples/manual-runtime.rs

@@ -8,18 +8,16 @@
 //! Note that the error handling is a bit left out. Also, the `run` could be modified to return the
 //! result of the provided future.
 
-extern crate futures;
-extern crate tokio;
-extern crate tokio_current_thread;
-extern crate tokio_executor;
-extern crate tokio_reactor;
-extern crate tokio_timer;
-
-use std::io::Error as IoError;
-use std::time::{Duration, Instant};
+#![deny(warnings, rust_2018_idioms)]
 
 use futures::{future, Future};
+use std::io::Error as IoError;
+use std::time::{Duration, Instant};
+use tokio;
+use tokio_current_thread;
 use tokio_current_thread::CurrentThread;
+use tokio_executor;
+use tokio_reactor;
 use tokio_reactor::Reactor;
 use tokio_timer::timer::{self, Timer};
 
@@ -60,7 +58,7 @@ fn run<F: Future<Item = (), Error = ()>>(f: F) -> Result<(), IoError> {
     Ok(())
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     run(future::lazy(|| {
         // Here comes the application logic. It can spawn further tasks by tokio_current_thread::spawn().
         // It also can use the default reactor and create timeouts.

tokio/examples/print_each_packet.rs

@@ -52,20 +52,17 @@
 //! ```
 //!
 
-#![deny(warnings)]
-
-extern crate tokio;
-extern crate tokio_codec;
+#![deny(warnings, rust_2018_idioms)]
 
+use std::env;
+use std::net::SocketAddr;
+use tokio;
 use tokio::codec::Decoder;
 use tokio::net::TcpListener;
 use tokio::prelude::*;
 use tokio_codec::BytesCodec;
 
-use std::env;
-use std::net::SocketAddr;
-
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Allow passing an address to listen on as the first argument of this
     // program, but otherwise we'll just set up our TCP listener on
     // 127.0.0.1:8080 for connections.

tokio/examples/proxy.rs

@@ -20,20 +20,18 @@
 //! This final terminal will connect to our proxy, which will in turn connect to
 //! the echo server, and you'll be able to see data flowing between them.
 
-#![deny(warnings)]
-
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
 use std::env;
 use std::io::{self, Read, Write};
 use std::net::{Shutdown, SocketAddr};
 use std::sync::{Arc, Mutex};
-
+use tokio;
 use tokio::io::{copy, shutdown};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::prelude::*;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());
     let listen_addr = listen_addr.parse::<SocketAddr>()?;
 

tokio/examples/tinydb.rs

@@ -39,16 +39,14 @@
 //! * `SET $key $value` - this will set the value of `$key` to `$value`,
 //!   returning the previous value, if any.
 
-#![deny(warnings)]
-
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
 use std::collections::HashMap;
 use std::env;
 use std::io::BufReader;
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
-
+use tokio;
 use tokio::io::{lines, write_all};
 use tokio::net::TcpListener;
 use tokio::prelude::*;
@@ -83,7 +81,7 @@ enum Response {
     },
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Parse the address we're going to run this server on
     // and set up our TCP listener to accept connections.
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());

tokio/examples/tinyhttp.rs

@@ -11,30 +11,23 @@
 //! respectively. By default this will run I/O on all the cores your system has
 //! available, and it doesn't support HTTP request bodies.
 
-#![deny(warnings)]
-
-extern crate bytes;
-extern crate http;
-extern crate httparse;
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_json;
-extern crate time;
-extern crate tokio;
-extern crate tokio_io;
+#![deny(warnings, rust_2018_idioms)]
 
+use bytes::BytesMut;
+use http;
+use http::header::HeaderValue;
+use http::{Request, Response, StatusCode};
+use httparse;
+use serde::Serialize;
+use serde_json;
 use std::net::SocketAddr;
 use std::{env, fmt, io};
-
+use tokio;
 use tokio::codec::{Decoder, Encoder};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::prelude::*;
 
-use bytes::BytesMut;
-use http::header::HeaderValue;
-use http::{Request, Response, StatusCode};
-
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Parse the arguments, bind the TCP socket we'll be listening to, spin up
     // our worker threads, and start shipping sockets to those worker threads.
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
@@ -82,7 +75,7 @@ fn process(socket: TcpStream) {
 /// This function is a map from and HTTP request to a future of a response and
 /// represents the various handling a server might do. Currently the contents
 /// here are pretty uninteresting.
-fn respond(req: Request<()>) -> Box<Future<Item = Response<String>, Error = io::Error> + Send> {
+fn respond(req: Request<()>) -> Box<dyn Future<Item = Response<String>, Error = io::Error> + Send> {
     let f = future::lazy(move || {
         let mut response = Response::builder();
         let body = match req.uri().path() {
@@ -163,7 +156,7 @@ impl Encoder for Http {
                 Ok(())
             }
 
-            fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+            fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
                 fmt::write(self, args)
             }
         }
@@ -286,7 +279,7 @@ mod date {
     }));
 
     impl fmt::Display for Now {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             LAST.with(|cache| {
                 let mut cache = cache.borrow_mut();
                 let now = time::get_time();

tokio/examples/udp-client.rs

@@ -26,8 +26,7 @@
 //! Please mind that since the UDP protocol doesn't have any capabilities to detect a broken
 //! connection the server needs to be run first, otherwise the client will block forever.
 
-extern crate futures;
-extern crate tokio;
+#![deny(warnings, rust_2018_idioms)]
 
 use std::env;
 use std::io::stdin;
@@ -35,13 +34,13 @@ use std::net::SocketAddr;
 use tokio::net::UdpSocket;
 use tokio::prelude::*;
 
-fn get_stdin_data() -> Result<Vec<u8>, Box<std::error::Error>> {
+fn get_stdin_data() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
     let mut buf = Vec::new();
     stdin().read_to_end(&mut buf)?;
     Ok(buf)
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let remote_addr: SocketAddr = env::args()
         .nth(1)
         .unwrap_or("127.0.0.1:8080".into())

tokio/examples/udp-codec.rs

@@ -6,20 +6,16 @@
 //! new message with a new destination. Overall, we then use this to construct a
 //! "ping pong" pair where two sockets are sending messages back and forth.
 
-#![deny(warnings)]
-
-extern crate env_logger;
-extern crate tokio;
-extern crate tokio_codec;
-extern crate tokio_io;
+#![deny(warnings, rust_2018_idioms)]
 
+use env_logger;
 use std::net::SocketAddr;
-
+use tokio;
 use tokio::net::{UdpFramed, UdpSocket};
 use tokio::prelude::*;
 use tokio_codec::BytesCodec;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let _ = env_logger::init();
 
     let addr: SocketAddr = "127.0.0.1:0".parse()?;