Upgrade to Rust 2018 edition.

Cargo.toml

@@ -2,6 +2,7 @@
 name = "solstice"
 version = "0.1.0"
 authors = ["letitz"]
+edition = "2018"
 
 [dependencies]
 byteorder = "^0.5.1"

src/client.rs

@@ -4,13 +4,13 @@ use std::sync::mpsc;
 use mio;
 use slab;
 
-use config;
-use control;
-use proto;
-use proto::peer;
-use proto::server;
-use room;
-use user;
+use crate::config;
+use crate::control;
+use crate::proto;
+use crate::proto::peer;
+use crate::proto::server;
+use crate::room;
+use crate::user;
 
 #[derive(Debug)]
 enum IncomingMessage {

src/control/response.rs

@@ -1,5 +1,5 @@
-use proto::User;
-use room;
+use crate::proto::User;
+use crate::room;
 
 /// This enumeration is the list of possible control responses from the client
 /// to the controller.

src/control/ws.rs

@@ -5,7 +5,7 @@ use std::sync::mpsc;
 use rustc_serialize::json;
 use ws;
 
-use config;
+use crate::config;
 
 use super::request::*;
 use super::response::*;
@@ -82,8 +82,8 @@ pub struct Sender {
 impl Sender {
     /// Queues up a control response to be sent to the controller.
     pub fn send(&mut self, response: Response) -> Result<(), SendError> {
-        let encoded = try!(json::encode(&response));
-        try!(self.sender.send(encoded));
+        let encoded = json::encode(&response)?;
+        self.sender.send(encoded)?;
         Ok(())
     }
 }

src/proto/codec.rs

@@ -123,7 +123,7 @@ mod tests {
     use bytes::BytesMut;
     use tokio_codec::{Decoder, Encoder};
 
-    use proto::ProtoEncode;
+    use crate::proto::ProtoEncode;
 
     use super::{LengthPrefixedDecoder, LengthPrefixedEncoder};
 

src/proto/handler.rs

@@ -7,7 +7,7 @@ use std::sync::mpsc;
 use mio;
 use slab;
 
-use config;
+use crate::config;
 
 use super::peer;
 use super::server::*;
@@ -104,7 +104,7 @@ fn listener_bind<U>(addr_spec: U) -> io::Result<mio::tcp::TcpListener>
 where
     U: ToSocketAddrs + fmt::Debug,
 {
-    for socket_addr in try!(addr_spec.to_socket_addrs()) {
+    for socket_addr in addr_spec.to_socket_addrs()? {
         if let Ok(listener) = mio::tcp::TcpListener::bind(&socket_addr) {
             return Ok(listener);
         }
@@ -122,33 +122,33 @@ impl Handler {
     ) -> io::Result<Self> {
         let host = config::SERVER_HOST;
         let port = config::SERVER_PORT;
-        let server_stream = try!(Stream::new(
+        let server_stream = Stream::new(
             (host, port),
             ServerResponseSender(client_tx.clone()),
-        ));
+        )?;
 
         info!("Connected to server at {}:{}", host, port);
 
-        let listener = try!(listener_bind((config::LISTEN_HOST, config::LISTEN_PORT)));
+        let listener = listener_bind((config::LISTEN_HOST, config::LISTEN_PORT))?;
         info!(
             "Listening for connections on {}:{}",
             config::LISTEN_HOST,
             config::LISTEN_PORT
         );
 
-        try!(event_loop.register(
+        event_loop.register(
             server_stream.evented(),
             mio::Token(SERVER_TOKEN),
             mio::Ready::all(),
             mio::PollOpt::edge() | mio::PollOpt::oneshot(),
-        ));
+        )?;
 
-        try!(event_loop.register(
+        event_loop.register(
             &listener,
             mio::Token(LISTEN_TOKEN),
             mio::Ready::all(),
             mio::PollOpt::edge() | mio::PollOpt::oneshot(),
-        ));
+        )?;
 
         Ok(Handler {
             server_stream: server_stream,
@@ -171,7 +171,7 @@ impl Handler {
         let vacant_entry = match self.peer_streams.entry(peer_id) {
             None => return Err("id out of range".to_string()),
 
-            Some(slab::Entry::Occupied(occupied_entry)) => {
+            Some(slab::Entry::Occupied(_occupied_entry)) => {
                 return Err("id already taken".to_string())
             }
 
@@ -270,7 +270,7 @@ impl mio::deprecated::Handler for Handler {
                 if event_set.is_readable() {
                     // A peer wants to connect to us.
                     match self.listener.accept() {
-                        Ok((sock, addr)) => {
+                        Ok((_sock, addr)) => {
                             // TODO add it to peer streams
                             info!("Peer connection accepted from {}", addr);
                         }
@@ -351,10 +351,10 @@ pub struct Agent {
 impl Agent {
     pub fn new(client_tx: mpsc::Sender<Response>) -> io::Result<Self> {
         // Create the event loop.
-        let mut event_loop = try!(mio::deprecated::EventLoop::new());
+        let mut event_loop = mio::deprecated::EventLoop::new()?;
         // Create the handler for the event loop and register the handler's
         // sockets with the event loop.
-        let handler = try!(Handler::new(client_tx, &mut event_loop));
+        let handler = Handler::new(client_tx, &mut event_loop)?;
 
         Ok(Agent {
             event_loop: event_loop,

src/proto/packet.rs

@@ -28,7 +28,7 @@ impl io::Read for Packet {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let bytes_read = {
             let mut slice = &self.bytes[self.cursor..];
-            try!(slice.read(buf))
+            slice.read(buf)?
         };
         self.cursor += bytes_read;
         Ok(bytes_read)
@@ -179,27 +179,27 @@ impl From<io::Error> for PacketReadError {
 /// This trait is implemented by types that can be deserialized from binary
 /// Packets.
 pub trait ReadFromPacket: Sized {
-    fn read_from_packet(&mut Packet) -> Result<Self, PacketReadError>;
+    fn read_from_packet(_: &mut Packet) -> Result<Self, PacketReadError>;
 }
 
 /// 32-bit integers are serialized in 4 bytes, little-endian.
 impl ReadFromPacket for u32 {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        Ok(try!(packet.read_u32::<LittleEndian>()))
+        Ok(packet.read_u32::<LittleEndian>()?)
     }
 }
 
 /// For convenience, usize's are deserialized as u32's then casted.
 impl ReadFromPacket for usize {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        Ok(try!(u32::read_from_packet(packet)) as usize)
+        Ok(u32::read_from_packet(packet)? as usize)
     }
 }
 
 /// Booleans are serialized as single bytes, containing either 0 or 1.
 impl ReadFromPacket for bool {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        match try!(packet.read_u8()) {
+        match packet.read_u8()? {
             0 => Ok(false),
             1 => Ok(true),
             n => Err(PacketReadError::InvalidBoolError(n)),
@@ -210,7 +210,7 @@ impl ReadFromPacket for bool {
 /// 16-bit integers are serialized as 32-bit integers.
 impl ReadFromPacket for u16 {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let n = try!(u32::read_from_packet(packet));
+        let n = u32::read_from_packet(packet)?;
         if n > MAX_PORT {
             return Err(PacketReadError::InvalidU16Error(n));
         }
@@ -221,7 +221,7 @@ impl ReadFromPacket for u16 {
 /// IPv4 addresses are serialized directly as 32-bit integers.
 impl ReadFromPacket for net::Ipv4Addr {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let ip = try!(u32::read_from_packet(packet));
+        let ip = u32::read_from_packet(packet)?;
         Ok(net::Ipv4Addr::from(ip))
     }
 }
@@ -230,10 +230,10 @@ impl ReadFromPacket for net::Ipv4Addr {
 /// characters.
 impl ReadFromPacket for String {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let len = try!(usize::read_from_packet(packet));
+        let len = usize::read_from_packet(packet)?;
 
         let mut buffer = vec![0; len];
-        try!(packet.read_exact(&mut buffer));
+        packet.read_exact(&mut buffer)?;
 
         match ISO_8859_1.decode(&buffer, DecoderTrap::Strict) {
             Ok(string) => Ok(string),
@@ -245,11 +245,11 @@ impl ReadFromPacket for String {
 /// Vectors are serialized as length-prefixed arrays of values.
 impl<T: ReadFromPacket> ReadFromPacket for Vec<T> {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let len = try!(usize::read_from_packet(packet));
+        let len = usize::read_from_packet(packet)?;
 
         let mut vec = Vec::new();
         for _ in 0..len {
-            vec.push(try!(T::read_from_packet(packet)));
+            vec.push(T::read_from_packet(packet)?);
         }
 
         Ok(vec)
@@ -263,7 +263,7 @@ impl<T: ReadFromPacket> ReadFromPacket for Vec<T> {
 /// This trait is implemented by types that can be serialized to a binary
 /// MutPacket.
 pub trait WriteToPacket {
-    fn write_to_packet(&self, &mut MutPacket) -> io::Result<()>;
+    fn write_to_packet(&self, _: &mut MutPacket) -> io::Result<()>;
 }
 
 /// 32-bit integers are serialized in 4 bytes, little-endian.
@@ -276,7 +276,7 @@ impl WriteToPacket for u32 {
 /// Booleans are serialized as single bytes, containing either 0 or 1.
 impl WriteToPacket for bool {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_u8(*self as u8));
+        packet.write_u8(*self as u8)?;
         Ok(())
     }
 }
@@ -301,8 +301,8 @@ impl WriteToPacket for str {
             }
         };
         // Then write the bytes to the packet.
-        try!((bytes.len() as u32).write_to_packet(packet));
-        try!(packet.write(&bytes));
+        (bytes.len() as u32).write_to_packet(packet)?;
+        packet.write(&bytes)?;
         Ok(())
     }
 }
@@ -361,7 +361,7 @@ impl Parser {
         // Try to read as many bytes as we currently need from the underlying
         // byte stream.
         let offset = self.buffer.len() - self.num_bytes_left;
-        match try!(stream.try_read(&mut self.buffer[offset..])) {
+        match stream.try_read(&mut self.buffer[offset..])? {
             None => (),
 
             Some(num_bytes_read) => {

src/proto/peer/message.rs

@@ -1,7 +1,7 @@
 use std::io;
 
-use proto::peer::constants::*;
-use proto::{
+use crate::proto::peer::constants::*;
+use crate::proto::{
     MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ReadFromPacket,
     WriteToPacket,
 };
@@ -20,11 +20,11 @@ pub enum Message {
 
 impl ReadFromPacket for Message {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let code: u32 = try!(packet.read_value());
+        let code: u32 = packet.read_value()?;
         let message = match code {
-            CODE_PIERCE_FIREWALL => Message::PierceFirewall(try!(packet.read_value())),
+            CODE_PIERCE_FIREWALL => Message::PierceFirewall(packet.read_value()?),
 
-            CODE_PEER_INIT => Message::PeerInit(try!(packet.read_value())),
+            CODE_PEER_INIT => Message::PeerInit(packet.read_value()?),
 
             code => Message::Unknown(code),
         };
@@ -85,13 +85,13 @@ impl WriteToPacket for Message {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         match *self {
             Message::PierceFirewall(ref token) => {
-                try!(packet.write_value(&CODE_PIERCE_FIREWALL));
-                try!(packet.write_value(token));
+                packet.write_value(&CODE_PIERCE_FIREWALL)?;
+                packet.write_value(token)?;
             }
 
             Message::PeerInit(ref request) => {
-                try!(packet.write_value(&CODE_PEER_INIT));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_PEER_INIT)?;
+                packet.write_value(request)?;
             }
 
             Message::Unknown(_) => unreachable!(),
@@ -109,9 +109,9 @@ pub struct PeerInit {
 
 impl ReadFromPacket for PeerInit {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let user_name = try!(packet.read_value());
-        let connection_type = try!(packet.read_value());
-        let token = try!(packet.read_value());
+        let user_name = packet.read_value()?;
+        let connection_type = packet.read_value()?;
+        let token = packet.read_value()?;
         Ok(PeerInit {
             user_name,
             connection_type,
@@ -122,9 +122,9 @@ impl ReadFromPacket for PeerInit {
 
 impl WriteToPacket for PeerInit {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.user_name));
-        try!(packet.write_value(&self.connection_type));
-        try!(packet.write_value(&self.token));
+        packet.write_value(&self.user_name)?;
+        packet.write_value(&self.connection_type)?;
+        packet.write_value(&self.token)?;
         Ok(())
     }
 }
@@ -157,8 +157,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::base_codec::tests::{expect_io_error, roundtrip};
-    use proto::ProtoDecoder;
+    use crate::proto::base_codec::tests::{expect_io_error, roundtrip};
+    use crate::proto::ProtoDecoder;
 
     use super::*;
 

src/proto/server/request.rs

@@ -3,9 +3,9 @@ use std::io;
 use crypto::digest::Digest;
 use crypto::md5::Md5;
 
-use proto::packet::{MutPacket, WriteToPacket};
-use proto::server::constants::*;
-use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder};
+use crate::proto::packet::{MutPacket, WriteToPacket};
+use crate::proto::server::constants::*;
+use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder};
 
 /* ------- *
  * Helpers *
@@ -40,57 +40,57 @@ impl WriteToPacket for ServerRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         match *self {
             ServerRequest::CannotConnectRequest(ref request) => {
-                try!(packet.write_value(&CODE_CANNOT_CONNECT));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_CANNOT_CONNECT)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::ConnectToPeerRequest(ref request) => {
-                try!(packet.write_value(&CODE_CONNECT_TO_PEER));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_CONNECT_TO_PEER)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::FileSearchRequest(ref request) => {
-                try!(packet.write_value(&CODE_FILE_SEARCH));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_FILE_SEARCH)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::LoginRequest(ref request) => {
-                try!(packet.write_value(&CODE_LOGIN));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_LOGIN)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::PeerAddressRequest(ref request) => {
-                try!(packet.write_value(&CODE_PEER_ADDRESS));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_PEER_ADDRESS)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::RoomJoinRequest(ref request) => {
-                try!(packet.write_value(&CODE_ROOM_JOIN));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_ROOM_JOIN)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::RoomLeaveRequest(ref request) => {
-                try!(packet.write_value(&CODE_ROOM_LEAVE));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_ROOM_LEAVE)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::RoomListRequest => {
-                try!(packet.write_value(&CODE_ROOM_LIST));
+                packet.write_value(&CODE_ROOM_LIST)?;
             }
 
             ServerRequest::RoomMessageRequest(ref request) => {
-                try!(packet.write_value(&CODE_ROOM_MESSAGE));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_ROOM_MESSAGE)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::SetListenPortRequest(ref request) => {
-                try!(packet.write_value(&CODE_SET_LISTEN_PORT));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_SET_LISTEN_PORT)?;
+                packet.write_value(request)?;
             }
 
             ServerRequest::UserStatusRequest(ref request) => {
-                try!(packet.write_value(&CODE_USER_STATUS));
-                try!(packet.write_value(request));
+                packet.write_value(&CODE_USER_STATUS)?;
+                packet.write_value(request)?;
             }
         }
         Ok(())
@@ -216,8 +216,8 @@ pub struct CannotConnectRequest {
 
 impl WriteToPacket for CannotConnectRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.token));
-        try!(packet.write_value(&self.user_name));
+        packet.write_value(&self.token)?;
+        packet.write_value(&self.user_name)?;
         Ok(())
     }
 }
@@ -250,9 +250,9 @@ pub struct ConnectToPeerRequest {
 
 impl WriteToPacket for ConnectToPeerRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.token));
-        try!(packet.write_value(&self.user_name));
-        try!(packet.write_value(&self.connection_type));
+        packet.write_value(&self.token)?;
+        packet.write_value(&self.user_name)?;
+        packet.write_value(&self.connection_type)?;
         Ok(())
     }
 }
@@ -290,8 +290,8 @@ pub struct FileSearchRequest {
 
 impl WriteToPacket for FileSearchRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.ticket));
-        try!(packet.write_value(&self.query));
+        packet.write_value(&self.ticket)?;
+        packet.write_value(&self.query)?;
         Ok(())
     }
 }
@@ -356,11 +356,11 @@ impl LoginRequest {
 
 impl WriteToPacket for LoginRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.username));
-        try!(packet.write_value(&self.password));
-        try!(packet.write_value(&self.major));
-        try!(packet.write_value(&self.digest));
-        try!(packet.write_value(&self.minor));
+        packet.write_value(&self.username)?;
+        packet.write_value(&self.password)?;
+        packet.write_value(&self.major)?;
+        packet.write_value(&self.digest)?;
+        packet.write_value(&self.minor)?;
         Ok(())
     }
 }
@@ -403,7 +403,7 @@ pub struct PeerAddressRequest {
 
 impl WriteToPacket for PeerAddressRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.username));
+        packet.write_value(&self.username)?;
         Ok(())
     }
 }
@@ -432,7 +432,7 @@ pub struct RoomJoinRequest {
 
 impl WriteToPacket for RoomJoinRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.room_name));
+        packet.write_value(&self.room_name)?;
         Ok(())
     }
 }
@@ -463,7 +463,7 @@ pub struct RoomLeaveRequest {
 
 impl WriteToPacket for RoomLeaveRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.room_name));
+        packet.write_value(&self.room_name)?;
         Ok(())
     }
 }
@@ -495,8 +495,8 @@ pub struct RoomMessageRequest {
 
 impl WriteToPacket for RoomMessageRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.room_name));
-        try!(packet.write_value(&self.message));
+        packet.write_value(&self.room_name)?;
+        packet.write_value(&self.message)?;
         Ok(())
     }
 }
@@ -527,7 +527,7 @@ pub struct SetListenPortRequest {
 
 impl WriteToPacket for SetListenPortRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.port));
+        packet.write_value(&self.port)?;
         Ok(())
     }
 }
@@ -556,7 +556,7 @@ pub struct UserStatusRequest {
 
 impl WriteToPacket for UserStatusRequest {
     fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(&self.user_name));
+        packet.write_value(&self.user_name)?;
         Ok(())
     }
 }
@@ -586,8 +586,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::base_codec::tests::{expect_io_error, roundtrip};
-    use proto::ProtoDecoder;
+    use crate::proto::base_codec::tests::{expect_io_error, roundtrip};
+    use crate::proto::ProtoDecoder;
 
     use super::*;
 

src/proto/server/response.rs

@@ -1,9 +1,9 @@
 use std::io;
 use std::net;
 
-use proto::packet::{Packet, PacketReadError, ReadFromPacket};
-use proto::server::constants::*;
-use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, User, UserStatus};
+use crate::proto::packet::{Packet, PacketReadError, ReadFromPacket};
+use crate::proto::server::constants::*;
+use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, User, UserStatus};
 
 /*=================*
  * SERVER RESPONSE *
@@ -36,52 +36,52 @@ pub enum ServerResponse {
 
 impl ReadFromPacket for ServerResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let code: u32 = try!(packet.read_value());
+        let code: u32 = packet.read_value()?;
         let resp = match code {
             CODE_CONNECT_TO_PEER => {
-                ServerResponse::ConnectToPeerResponse(try!(packet.read_value()))
+                ServerResponse::ConnectToPeerResponse(packet.read_value()?)
             }
 
-            CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(try!(packet.read_value())),
+            CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(packet.read_value()?),
 
-            CODE_LOGIN => ServerResponse::LoginResponse(try!(packet.read_value())),
+            CODE_LOGIN => ServerResponse::LoginResponse(packet.read_value()?),
 
-            CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(try!(packet.read_value())),
+            CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(packet.read_value()?),
 
             CODE_PRIVILEGED_USERS => {
-                ServerResponse::PrivilegedUsersResponse(try!(packet.read_value()))
+                ServerResponse::PrivilegedUsersResponse(packet.read_value()?)
             }
 
-            CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(try!(packet.read_value())),
+            CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(packet.read_value()?),
 
-            CODE_ROOM_LEAVE => ServerResponse::RoomLeaveResponse(try!(packet.read_value())),
+            CODE_ROOM_LEAVE => ServerResponse::RoomLeaveResponse(packet.read_value()?),
 
-            CODE_ROOM_LIST => ServerResponse::RoomListResponse(try!(packet.read_value())),
+            CODE_ROOM_LIST => ServerResponse::RoomListResponse(packet.read_value()?),
 
-            CODE_ROOM_MESSAGE => ServerResponse::RoomMessageResponse(try!(packet.read_value())),
+            CODE_ROOM_MESSAGE => ServerResponse::RoomMessageResponse(packet.read_value()?),
 
-            CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(try!(packet.read_value())),
+            CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(packet.read_value()?),
 
             CODE_ROOM_USER_JOINED => {
-                ServerResponse::RoomUserJoinedResponse(try!(packet.read_value()))
+                ServerResponse::RoomUserJoinedResponse(packet.read_value()?)
             }
 
-            CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(try!(packet.read_value())),
+            CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(packet.read_value()?),
 
-            CODE_USER_INFO => ServerResponse::UserInfoResponse(try!(packet.read_value())),
+            CODE_USER_INFO => ServerResponse::UserInfoResponse(packet.read_value()?),
 
-            CODE_USER_STATUS => ServerResponse::UserStatusResponse(try!(packet.read_value())),
+            CODE_USER_STATUS => ServerResponse::UserStatusResponse(packet.read_value()?),
 
             CODE_WISHLIST_INTERVAL => {
-                ServerResponse::WishlistIntervalResponse(try!(packet.read_value()))
+                ServerResponse::WishlistIntervalResponse(packet.read_value()?)
             }
 
             CODE_PARENT_MIN_SPEED => {
-                ServerResponse::ParentMinSpeedResponse(try!(packet.read_value()))
+                ServerResponse::ParentMinSpeedResponse(packet.read_value()?)
             }
 
             CODE_PARENT_SPEED_RATIO => {
-                ServerResponse::ParentSpeedRatioResponse(try!(packet.read_value()))
+                ServerResponse::ParentSpeedRatioResponse(packet.read_value()?)
             }
 
             code => ServerResponse::UnknownResponse(code),
@@ -275,12 +275,12 @@ pub struct ConnectToPeerResponse {
 
 impl ReadFromPacket for ConnectToPeerResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let user_name = try!(packet.read_value());
-        let connection_type = try!(packet.read_value());
-        let ip = try!(packet.read_value());
-        let port = try!(packet.read_value());
-        let token = try!(packet.read_value());
-        let is_privileged = try!(packet.read_value());
+        let user_name = packet.read_value()?;
+        let connection_type = packet.read_value()?;
+        let ip = packet.read_value()?;
+        let port = packet.read_value()?;
+        let token = packet.read_value()?;
+        let is_privileged = packet.read_value()?;
 
         Ok(ConnectToPeerResponse {
             user_name,
@@ -337,9 +337,9 @@ pub struct FileSearchResponse {
 
 impl ReadFromPacket for FileSearchResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let user_name = try!(packet.read_value());
-        let ticket = try!(packet.read_value());
-        let query = try!(packet.read_value());
+        let user_name = packet.read_value()?;
+        let ticket = packet.read_value()?;
+        let query = packet.read_value()?;
 
         Ok(FileSearchResponse {
             user_name,
@@ -389,10 +389,10 @@ pub enum LoginResponse {
 
 impl ReadFromPacket for LoginResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let ok = try!(packet.read_value());
+        let ok = packet.read_value()?;
         if ok {
-            let motd = try!(packet.read_value());
-            let ip = try!(packet.read_value());
+            let motd = packet.read_value()?;
+            let ip = packet.read_value()?;
 
             match packet.read_value::<bool>() {
                 Ok(value) => debug!("LoginResponse last field: {}", value),
@@ -406,7 +406,7 @@ impl ReadFromPacket for LoginResponse {
             })
         } else {
             Ok(LoginResponse::LoginFail {
-                reason: try!(packet.read_value()),
+                reason: packet.read_value()?,
             })
         }
     }
@@ -469,7 +469,7 @@ pub struct ParentMinSpeedResponse {
 
 impl ReadFromPacket for ParentMinSpeedResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let value = try!(packet.read_value());
+        let value = packet.read_value()?;
         Ok(ParentMinSpeedResponse { value })
     }
 }
@@ -498,7 +498,7 @@ pub struct ParentSpeedRatioResponse {
 
 impl ReadFromPacket for ParentSpeedRatioResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let value = try!(packet.read_value());
+        let value = packet.read_value()?;
         Ok(ParentSpeedRatioResponse { value })
     }
 }
@@ -529,9 +529,9 @@ pub struct PeerAddressResponse {
 
 impl ReadFromPacket for PeerAddressResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let username = try!(packet.read_value());
-        let ip = try!(packet.read_value());
-        let port = try!(packet.read_value());
+        let username = packet.read_value()?;
+        let ip = packet.read_value()?;
+        let port = packet.read_value()?;
 
         Ok(PeerAddressResponse { username, ip, port })
     }
@@ -565,7 +565,7 @@ pub struct PrivilegedUsersResponse {
 
 impl ReadFromPacket for PrivilegedUsersResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let users = try!(packet.read_value());
+        let users = packet.read_value()?;
         Ok(PrivilegedUsersResponse { users })
     }
 }
@@ -598,15 +598,15 @@ pub struct RoomJoinResponse {
 impl ReadFromPacket for RoomJoinResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
         let mut response = RoomJoinResponse {
-            room_name: try!(packet.read_value()),
+            room_name: packet.read_value()?,
             users: Vec::new(),
             owner: None,
             operators: Vec::new(),
         };
 
-        let num_users: usize = try!(packet.read_value());
+        let num_users: usize = packet.read_value()?;
         for _ in 0..num_users {
-            let name: String = try!(packet.read_value());
+            let name: String = packet.read_value()?;
             let user = User {
                 name,
                 status: UserStatus::Offline,
@@ -621,14 +621,14 @@ impl ReadFromPacket for RoomJoinResponse {
             response.users.push(user);
         }
 
-        try!(response.read_user_infos(packet));
+        response.read_user_infos(packet)?;
 
         if packet.bytes_remaining() > 0 {
-            response.owner = Some(try!(packet.read_value()));
+            response.owner = Some(packet.read_value()?);
 
-            let num_operators: usize = try!(packet.read_value());
+            let num_operators: usize = packet.read_value()?;
             for _ in 0..num_operators {
-                response.operators.push(try!(packet.read_value()));
+                response.operators.push(packet.read_value()?);
             }
         }
 
@@ -638,35 +638,35 @@ impl ReadFromPacket for RoomJoinResponse {
 
 impl RoomJoinResponse {
     fn read_user_infos(&mut self, packet: &mut Packet) -> Result<(), PacketReadError> {
-        let num_statuses: usize = try!(packet.read_value());
+        let num_statuses: usize = packet.read_value()?;
         for i in 0..num_statuses {
             if let Some(user) = self.users.get_mut(i) {
-                user.status = try!(packet.read_value());
+                user.status = packet.read_value()?;
             }
         }
 
-        let num_infos: usize = try!(packet.read_value());
+        let num_infos: usize = packet.read_value()?;
         for i in 0..num_infos {
             if let Some(user) = self.users.get_mut(i) {
-                user.average_speed = try!(packet.read_value());
-                user.num_downloads = try!(packet.read_value());
-                user.unknown = try!(packet.read_value());
-                user.num_files = try!(packet.read_value());
-                user.num_folders = try!(packet.read_value());
+                user.average_speed = packet.read_value()?;
+                user.num_downloads = packet.read_value()?;
+                user.unknown = packet.read_value()?;
+                user.num_files = packet.read_value()?;
+                user.num_folders = packet.read_value()?;
             }
         }
 
-        let num_free_slots: usize = try!(packet.read_value());
+        let num_free_slots: usize = packet.read_value()?;
         for i in 0..num_free_slots {
             if let Some(user) = self.users.get_mut(i) {
-                user.num_free_slots = try!(packet.read_value());
+                user.num_free_slots = packet.read_value()?;
             }
         }
 
-        let num_countries: usize = try!(packet.read_value());
+        let num_countries: usize = packet.read_value()?;
         for i in 0..num_countries {
             if let Some(user) = self.users.get_mut(i) {
-                user.country = try!(packet.read_value());
+                user.country = packet.read_value()?;
             }
         }
 
@@ -861,7 +861,7 @@ pub struct RoomLeaveResponse {
 impl ReadFromPacket for RoomLeaveResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
         Ok(RoomLeaveResponse {
-            room_name: try!(packet.read_value()),
+            room_name: packet.read_value()?,
         })
     }
 }
@@ -893,10 +893,10 @@ pub struct RoomListResponse {
 
 impl ReadFromPacket for RoomListResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let rooms = try!(Self::read_rooms(packet));
-        let owned_private_rooms = try!(Self::read_rooms(packet));
-        let other_private_rooms = try!(Self::read_rooms(packet));
-        let operated_private_room_names = try!(packet.read_value());
+        let rooms = Self::read_rooms(packet)?;
+        let owned_private_rooms = Self::read_rooms(packet)?;
+        let other_private_rooms = Self::read_rooms(packet)?;
+        let operated_private_room_names = packet.read_value()?;
         Ok(RoomListResponse {
             rooms,
             owned_private_rooms,
@@ -908,17 +908,17 @@ impl ReadFromPacket for RoomListResponse {
 
 impl RoomListResponse {
     fn read_rooms(packet: &mut Packet) -> Result<Vec<(String, u32)>, PacketReadError> {
-        let num_rooms: usize = try!(packet.read_value());
+        let num_rooms: usize = packet.read_value()?;
         let mut rooms = Vec::new();
         for _ in 0..num_rooms {
-            let room_name = try!(packet.read_value());
+            let room_name = packet.read_value()?;
             rooms.push((room_name, 0));
         }
 
-        let num_user_counts: usize = try!(packet.read_value());
+        let num_user_counts: usize = packet.read_value()?;
         for i in 0..num_user_counts {
             if let Some(&mut (_, ref mut count)) = rooms.get_mut(i) {
-                *count = try!(packet.read_value());
+                *count = packet.read_value()?;
             }
         }
 
@@ -1019,9 +1019,9 @@ pub struct RoomMessageResponse {
 
 impl ReadFromPacket for RoomMessageResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let room_name = try!(packet.read_value());
-        let user_name = try!(packet.read_value());
-        let message = try!(packet.read_value());
+        let room_name = packet.read_value()?;
+        let user_name = packet.read_value()?;
+        let message = packet.read_value()?;
         Ok(RoomMessageResponse {
             room_name,
             user_name,
@@ -1063,13 +1063,13 @@ pub struct RoomTickersResponse {
 
 impl ReadFromPacket for RoomTickersResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let room_name = try!(packet.read_value());
+        let room_name = packet.read_value()?;
 
-        let num_tickers: usize = try!(packet.read_value());
+        let num_tickers: usize = packet.read_value()?;
         let mut tickers = Vec::new();
         for _ in 0..num_tickers {
-            let user_name = try!(packet.read_value());
-            let message = try!(packet.read_value());
+            let user_name = packet.read_value()?;
+            let message = packet.read_value()?;
             tickers.push((user_name, message))
         }
 
@@ -1104,19 +1104,19 @@ pub struct RoomUserJoinedResponse {
 
 impl ReadFromPacket for RoomUserJoinedResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let room_name = try!(packet.read_value());
-        let user_name = try!(packet.read_value());
+        let room_name = packet.read_value()?;
+        let user_name = packet.read_value()?;
 
-        let status = try!(packet.read_value());
+        let status = packet.read_value()?;
 
-        let average_speed = try!(packet.read_value());
-        let num_downloads = try!(packet.read_value());
-        let unknown = try!(packet.read_value());
-        let num_files = try!(packet.read_value());
-        let num_folders = try!(packet.read_value());
-        let num_free_slots = try!(packet.read_value());
+        let average_speed = packet.read_value()?;
+        let num_downloads = packet.read_value()?;
+        let unknown = packet.read_value()?;
+        let num_files = packet.read_value()?;
+        let num_folders = packet.read_value()?;
+        let num_free_slots = packet.read_value()?;
 
-        let country = try!(packet.read_value());
+        let country = packet.read_value()?;
 
         Ok(RoomUserJoinedResponse {
             room_name,
@@ -1173,8 +1173,8 @@ pub struct RoomUserLeftResponse {
 
 impl ReadFromPacket for RoomUserLeftResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let room_name = try!(packet.read_value());
-        let user_name = try!(packet.read_value());
+        let room_name = packet.read_value()?;
+        let user_name = packet.read_value()?;
         Ok(RoomUserLeftResponse {
             room_name,
             user_name,
@@ -1215,11 +1215,11 @@ pub struct UserInfoResponse {
 
 impl ReadFromPacket for UserInfoResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let user_name = try!(packet.read_value());
-        let average_speed = try!(packet.read_value());
-        let num_downloads = try!(packet.read_value());
-        let num_files = try!(packet.read_value());
-        let num_folders = try!(packet.read_value());
+        let user_name = packet.read_value()?;
+        let average_speed = packet.read_value()?;
+        let num_downloads = packet.read_value()?;
+        let num_files = packet.read_value()?;
+        let num_folders = packet.read_value()?;
         Ok(UserInfoResponse {
             user_name,
             average_speed,
@@ -1270,9 +1270,9 @@ pub struct UserStatusResponse {
 
 impl ReadFromPacket for UserStatusResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let user_name = try!(packet.read_value());
-        let status = try!(packet.read_value());
-        let is_privileged = try!(packet.read_value());
+        let user_name = packet.read_value()?;
+        let status = packet.read_value()?;
+        let is_privileged = packet.read_value()?;
         Ok(UserStatusResponse {
             user_name,
             status,
@@ -1313,7 +1313,7 @@ pub struct WishlistIntervalResponse {
 
 impl ReadFromPacket for WishlistIntervalResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let seconds = try!(packet.read_value());
+        let seconds = packet.read_value()?;
         Ok(WishlistIntervalResponse { seconds })
     }
 }
@@ -1342,8 +1342,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::base_codec::tests::{expect_io_error, roundtrip};
-    use proto::ProtoDecoder;
+    use crate::proto::base_codec::tests::{expect_io_error, roundtrip};
+    use crate::proto::ProtoDecoder;
 
     use super::*;
 

src/proto/stream.rs

@@ -61,7 +61,7 @@ pub trait SendPacket {
     type Value: ReadFromPacket;
     type Error: error::Error;
 
-    fn send_packet(&mut self, Self::Value) -> Result<(), Self::Error>;
+    fn send_packet(&mut self, _: Self::Value) -> Result<(), Self::Error>;
 
     fn notify_open(&mut self) -> Result<(), Self::Error>;
 }
@@ -97,7 +97,7 @@ impl<T: SendPacket> Stream<T> {
     where
         U: ToSocketAddrs + fmt::Debug,
     {
-        for sock_addr in try!(addr_spec.to_socket_addrs()) {
+        for sock_addr in addr_spec.to_socket_addrs()? {
             if let Ok(stream) = mio::tcp::TcpStream::connect(&sock_addr) {
                 return Ok(Stream {
                     parser: Parser::new(),
@@ -148,7 +148,7 @@ impl<T: SendPacket> Stream<T> {
                 None => break,
             };
 
-            let option = try!(outbuf.try_write_to(&mut self.stream));
+            let option = outbuf.try_write_to(&mut self.stream)?;
             match option {
                 Some(_) => {
                     if outbuf.has_remaining() {

src/proto/transport.rs

@@ -5,8 +5,8 @@ use bytes::BytesMut;
 use tokio_io::codec::length_delimited::{Builder, Framed};
 use tokio_io::{AsyncRead, AsyncWrite};
 
-use proto::peer;
-use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ServerRequest, ServerResponse};
+use crate::proto::peer;
+use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ServerRequest, ServerResponse};
 
 fn decode_frame<'a, T>(frame_type: &str, bytes: &'a mut BytesMut) -> io::Result<T>
 where

src/proto/user.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use proto::{
+use crate::proto::{
     MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ReadFromPacket,
     WriteToPacket,
 };
@@ -22,7 +22,7 @@ pub enum UserStatus {
 
 impl ReadFromPacket for UserStatus {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let n: u32 = try!(packet.read_value());
+        let n: u32 = packet.read_value()?;
         match n {
             STATUS_OFFLINE => Ok(UserStatus::Offline),
             STATUS_AWAY => Ok(UserStatus::Away),
@@ -39,7 +39,7 @@ impl WriteToPacket for UserStatus {
             UserStatus::Away => STATUS_AWAY,
             UserStatus::Online => STATUS_ONLINE,
         };
-        try!(packet.write_value(&n));
+        packet.write_value(&n)?;
         Ok(())
     }
 }

src/room.rs

@@ -3,7 +3,7 @@ use std::error;
 use std::fmt;
 use std::mem;
 
-use proto::{server, User};
+use crate::proto::{server, User};
 
 /// This enumeration is the list of possible membership states for a chat room.
 #[derive(Clone, Copy, Debug, RustcDecodable, RustcEncodable)]
@@ -211,7 +211,7 @@ impl RoomMap {
     /// If the room is not found, or if its membership is not `NonMember`,
     /// returns an error.
     pub fn start_joining(&mut self, room_name: &str) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
 
         match room.membership {
             Membership::NonMember => {
@@ -236,7 +236,7 @@ impl RoomMap {
         members: &[User],
     ) -> Result<(), Error> {
         // First look up the room struct.
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
 
         // Log what's happening.
         if let Membership::Joining = room.membership {
@@ -270,7 +270,7 @@ impl RoomMap {
     /// If the room is not found, or if its membership status is not `Member`,
     /// returns an error.
     pub fn start_leaving(&mut self, room_name: &str) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
 
         match room.membership {
             Membership::Member => {
@@ -287,7 +287,7 @@ impl RoomMap {
 
     /// Records that we have now left the given room.
     pub fn leave(&mut self, room_name: &str) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
 
         match room.membership {
             Membership::Leaving => info!("Left room {:?}", room_name),
@@ -304,7 +304,7 @@ impl RoomMap {
 
     /// Saves the given message as the last one in the given room.
     pub fn add_message(&mut self, room_name: &str, message: Message) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
         room.messages.push(message);
         Ok(())
     }
@@ -312,7 +312,7 @@ impl RoomMap {
     /// Inserts the given user in the given room's set of members.
     /// Returns an error if the room is not found.
     pub fn insert_member(&mut self, room_name: &str, user_name: String) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
         room.members.insert(user_name);
         Ok(())
     }
@@ -320,7 +320,7 @@ impl RoomMap {
     /// Removes the given user from the given room's set of members.
     /// Returns an error if the room is not found.
     pub fn remove_member(&mut self, room_name: &str, user_name: &str) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
         room.members.remove(user_name);
         Ok(())
     }
@@ -334,7 +334,7 @@ impl RoomMap {
         room_name: &str,
         tickers: Vec<(String, String)>,
     ) -> Result<(), Error> {
-        let room = try!(self.get_mut_strict(room_name));
+        let room = self.get_mut_strict(room_name)?;
         room.tickers = tickers;
         Ok(())
     }

src/user.rs

@@ -2,7 +2,7 @@ use std::collections;
 use std::error;
 use std::fmt;
 
-use proto::{User, UserStatus};
+use crate::proto::{User, UserStatus};
 
 /// The error returned when a user name was not found in the user map.
 #[derive(Debug)]