Update to Rust 2018

Author: SSheldon

Cargo.toml

@@ -2,6 +2,7 @@
 name = "objc"
 version = "0.2.6"
 authors = ["Steven Sheldon"]
+edition = "2018"
 
 description = "Objective-C Runtime bindings and wrapper for Rust."
 keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]

src/declare.rs

@@ -38,8 +38,8 @@ use std::ffi::CString;
 use std::mem;
 use std::ptr;
 
-use runtime::{BOOL, Class, Imp, NO, Object, Protocol, Sel, self};
-use {Encode, EncodeArguments, Encoding, Message};
+use crate::runtime::{BOOL, Class, Imp, NO, Object, Protocol, Sel, self};
+use crate::{Encode, EncodeArguments, Encoding, Message};
 
 /// Types that can be used as the implementation of an Objective-C method.
 pub trait MethodImplementation {
@@ -315,7 +315,7 @@ impl ProtocolDecl {
 
 #[cfg(test)]
 mod tests {
-    use test_utils;
+    use crate::test_utils;
 
     #[test]
     fn test_custom_class() {

src/encode.rs

@@ -1,5 +1,5 @@
-use runtime::{Class, Object, Sel};
-use {Encode, Encoding};
+use crate::runtime::{Class, Object, Sel};
+use crate::{Encode, Encoding};
 
 unsafe impl Encode for Sel {
     const ENCODING: Encoding<'static> = Encoding::Sel;
@@ -55,7 +55,7 @@ encode_args_impl!(A, B, C, D, E, F, G, H, I, J, K, L);
 #[cfg(test)]
 mod tests {
     use objc_encode::Encode;
-    use runtime::{Class, Object, Sel};
+    use crate::runtime::{Class, Object, Sel};
 
     #[test]
     fn test_encode() {

src/exception.rs

@@ -1,11 +1,11 @@
 use objc_exception;
 
-use rc::StrongPtr;
-use runtime::Object;
+use crate::rc::StrongPtr;
+use crate::runtime::Object;
 
-pub unsafe fn try<F, R>(closure: F) -> Result<R, StrongPtr>
+pub unsafe fn r#try<F, R>(closure: F) -> Result<R, StrongPtr>
         where F: FnOnce() -> R {
-    objc_exception::try(closure).map_err(|exception| {
+    objc_exception::r#try(closure).map_err(|exception| {
         StrongPtr::new(exception as *mut Object)
     })
 }

src/lib.rs

@@ -72,11 +72,11 @@ extern crate objc_exception;
 
 pub use objc_encode::{Encode, Encoding};
 
-pub use encode::EncodeArguments;
-pub use message::{Message, MessageArguments, MessageError};
+pub use crate::encode::EncodeArguments;
+pub use crate::message::{Message, MessageArguments, MessageError};
 
-pub use message::send_message as __send_message;
-pub use message::send_super_message as __send_super_message;
+pub use crate::message::send_message as __send_message;
+pub use crate::message::send_super_message as __send_super_message;
 
 #[macro_use]
 mod macros;

src/message/apple/mod.rs

@@ -1,6 +1,6 @@
 use std::any::Any;
 
-use runtime::{Class, Object, Sel};
+use crate::runtime::{Class, Object, Sel};
 use super::{Message, MessageArguments, MessageError, Super};
 
 #[cfg(target_arch = "x86")]

src/message/apple/x86_64.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use runtime::Imp;
+use crate::runtime::Imp;
 
 extern {
     fn objc_msgSend();

src/message/mod.rs

@@ -3,13 +3,13 @@ use std::error::Error;
 use std::fmt;
 use std::mem;
 
-use runtime::{Class, Imp, Object, Sel};
-use {Encode, EncodeArguments};
+use crate::runtime::{Class, Imp, Object, Sel};
+use crate::{Encode, EncodeArguments};
 
 #[cfg(feature = "exception")]
 macro_rules! objc_try {
     ($b:block) => (
-        $crate::exception::try(|| $b).map_err(|exception|
+        $crate::exception::r#try(|| $b).map_err(|exception|
             if exception.is_null() {
                 MessageError("Uncaught exception nil".to_owned())
             } else {
@@ -223,8 +223,8 @@ pub unsafe fn send_super_message<T, A, R>(obj: *const T, superclass: &Class,
 
 #[cfg(test)]
 mod tests {
-    use test_utils;
-    use runtime::Object;
+    use crate::test_utils;
+    use crate::runtime::Object;
     use super::Message;
 
     #[test]

src/message/verify.rs

@@ -1,5 +1,5 @@
-use runtime::{Class, Object, Sel};
-use {Encode, EncodeArguments};
+use crate::runtime::{Class, Object, Sel};
+use crate::{Encode, EncodeArguments};
 use super::MessageError;
 
 pub fn verify_message_signature<A, R>(cls: &Class, sel: Sel)

src/rc/autorelease.rs

@@ -1,5 +1,5 @@
 use std::os::raw::c_void;
-use runtime::{objc_autoreleasePoolPush, objc_autoreleasePoolPop};
+use crate::runtime::{objc_autoreleasePoolPush, objc_autoreleasePoolPop};
 
 // we use a struct to ensure that objc_autoreleasePoolPop during unwinding.
 struct AutoReleaseHelper {

src/rc/mod.rs

@@ -51,7 +51,7 @@ pub use self::autorelease::autoreleasepool;
 // These tests use NSObject, which isn't present for GNUstep
 #[cfg(all(test, any(target_os = "macos", target_os = "ios")))]
 mod tests {
-    use runtime::Object;
+    use crate::runtime::Object;
     use super::StrongPtr;
     use super::autoreleasepool;
 

src/rc/strong.rs

@@ -2,7 +2,7 @@ use std::fmt;
 use std::mem;
 use std::ops::Deref;
 
-use runtime::{Object, self};
+use crate::runtime::{Object, self};
 use super::WeakPtr;
 
 /// A pointer that strongly references an object, ensuring it won't be deallocated.

src/rc/weak.rs

@@ -1,7 +1,7 @@
 use std::cell::UnsafeCell;
 use std::ptr;
 
-use runtime::{Object, self};
+use crate::runtime::{Object, self};
 use super::StrongPtr;
 
 // Our pointer must have the same address even if we are moved, so Box it.

src/runtime.rs

@@ -10,7 +10,7 @@ use std::ptr;
 use std::str;
 use malloc_buf::Malloc;
 
-use Encode;
+use crate::Encode;
 
 /// The Objective-C `BOOL` type.
 ///
@@ -526,8 +526,8 @@ impl fmt::Debug for Object {
 
 #[cfg(test)]
 mod tests {
-    use test_utils;
-    use Encode;
+    use crate::test_utils;
+    use crate::Encode;
     use super::{Class, Protocol, Sel};
 
     #[test]

src/test_utils.rs

@@ -2,9 +2,9 @@ use std::ops::{Deref, DerefMut};
 use std::os::raw::c_char;
 use std::sync::{Once, ONCE_INIT};
 
-use declare::{ClassDecl, ProtocolDecl};
-use runtime::{Class, Object, Protocol, Sel, self};
-use {Encode, Encoding};
+use crate::declare::{ClassDecl, ProtocolDecl};
+use crate::runtime::{Class, Object, Protocol, Sel, self};
+use crate::{Encode, Encoding};
 
 pub struct CustomObject {
     obj: *mut Object,