Upgrade to 2018 edition

Author: Boddlnagg

Cargo.toml

@@ -11,6 +11,7 @@ keywords = ["winrt", "uwp", "windows", "runtime", "com"]
 categories = ["os::windows-apis", "api-bindings", "external-ffi-bindings"]
 license = "MIT OR Apache-2.0"
 exclude = ["Generator/**"]
+edition = "2018"
 
 [dependencies]
 winapi = { version = "0.3", features = ["winnt", "combaseapi", "oleauto", "roapi", "roerrorapi", "hstring", "winstring", "winerror", "restrictederrorinfo"] }

Generator/Generator.cs

@@ -130,7 +130,7 @@ private void WriteModuleTreeMultiFile(Module mod, DirectoryInfo directory, Strea
         {
             if (mod.IsEmpty) return;
 
-            const string IMPORTS = "use ::prelude::*;";
+            const string IMPORTS = "use crate::prelude::*;";
 
             string name = mod.Name.ToLower();
             string newPath = path == null ? mod.Name : (path + "." + mod.Name);

Generator/Types/TypeDef.cs

@@ -214,7 +214,7 @@ public string GetPath(Module requestingModule)
                 }
                 else
                 {
-                    name = $"::rt::gen::{ Module.Path }::{ Name }";
+                    name = $"crate::{ Module.Path }::{ Name }";
                 }
                 var relative = $"{ Module.GetRelativePath(requestingModule) }::{ Name }";
                 if (relative.Length < name.Length)

examples/hexdump.rs

@@ -15,7 +15,7 @@ const CHUNK_SIZE: usize = 4096;
 
 fn main() {
     // Use the current executable as source file (because we know that will exist).
-    let exe_path = ::std::env::current_exe().expect("current_exe failed");
+    let exe_path = std::env::current_exe().expect("current_exe failed");
     let exe_path_str = exe_path.to_str().expect("invalid unicode path");
 
     let file = StorageFile::get_file_from_path_async(&*FastHString::new(&exe_path_str)).unwrap().blocking_get().expect("get_file_from_path_async failed").unwrap();

examples/test.rs

@@ -144,7 +144,7 @@ fn main() {
     assert!(asi.close().is_ok());
 
     // Walk directories up to root
-    let exe_path = ::std::env::current_exe().expect("current_exe failed");
+    let exe_path = std::env::current_exe().expect("current_exe failed");
     let exe_path_str = exe_path.to_str().expect("invalid unicode path");
     let file = StorageFile::get_file_from_path_async(&*FastHString::new(&exe_path_str)).unwrap().blocking_get().expect("get_file_from_path_async failed").unwrap();
     println!("Executable file: {}", file.query_interface::<IStorageItem>().unwrap().get_path().unwrap());

src/bstr.rs

@@ -1,5 +1,5 @@
-use ::std::ptr;
-use ::std::fmt;
+use std::ptr;
+use std::fmt;
 
 use w::shared::wtypes::BSTR;
 use w::shared::basetsd::UINT32;
@@ -63,7 +63,7 @@ impl BStr {
         } else {
             unsafe {
                 let len = self.len();
-                let slice: &[u16] = ::std::slice::from_raw_parts(self.0, len as usize);
+                let slice: &[u16] = std::slice::from_raw_parts(self.0, len as usize);
                 String::from_utf16_lossy(slice)
             }
         }

src/cominterfaces.rs

@@ -1,4 +1,4 @@
-use Guid;
+use crate::Guid;
 use w::um::unknwnbase::IUnknownVtbl;
 
 /// Marker trait for all COM-compatible interfaces.
@@ -21,15 +21,15 @@ pub trait ComIid {
 DEFINE_IID!(IID_IUnknown, 0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
 
 /// Re-export from WinAPI crate
-pub type IUnknown = ::w::um::unknwnbase::IUnknown;
+pub type IUnknown = w::um::unknwnbase::IUnknown;
 impl ComIid for IUnknown { #[inline] fn iid() -> &'static Guid { &IID_IUnknown } }
 impl ComInterface for IUnknown { type Vtbl = IUnknownVtbl; }
 
 DEFINE_IID!(IID_IRestrictedErrorInfo, 0x82BA7092, 0x4C88, 0x427D, 0xA7, 0xBC, 0x16, 0xDD, 0x93, 0xFE, 0xB6, 0x7E);
 
 /// Re-export from WinAPI crate
-pub type IRestrictedErrorInfo = ::w::um::restrictederrorinfo::IRestrictedErrorInfo;
-pub type IRestrictedErrorInfoVtbl = ::w::um::restrictederrorinfo::IRestrictedErrorInfoVtbl;
+pub type IRestrictedErrorInfo = w::um::restrictederrorinfo::IRestrictedErrorInfo;
+pub type IRestrictedErrorInfoVtbl = w::um::restrictederrorinfo::IRestrictedErrorInfoVtbl;
 impl ComIid for IRestrictedErrorInfo { #[inline] fn iid() -> &'static Guid { &IID_IRestrictedErrorInfo } }
 impl ComInterface for IRestrictedErrorInfo { type Vtbl = IRestrictedErrorInfoVtbl; }
 
@@ -42,17 +42,17 @@ DEFINE_IID!(IID_IAgileObject, 0x94EA2B94, 0xE9CC, 0x49E0, 0xC0, 0xFF, 0xEE, 0x64
 pub struct IAgileObject {
     lpVtbl: *const IUnknownVtbl // IAgileObject has no methods besides what IUnknown has
 }
-impl ::std::ops::Deref for IAgileObject {
+impl std::ops::Deref for IAgileObject {
     type Target = IUnknown;
     #[inline]
     fn deref(&self) -> &IUnknown {
-        unsafe { ::std::mem::transmute(self) }
+        unsafe { std::mem::transmute(self) }
     }
 }
-impl ::std::ops::DerefMut for IAgileObject {
+impl std::ops::DerefMut for IAgileObject {
     #[inline]
     fn deref_mut(&mut self) -> &mut IUnknown {
-        unsafe { ::std::mem::transmute(self) }
+        unsafe { std::mem::transmute(self) }
     }
 }
 impl ComIid for IAgileObject { #[inline] fn iid() -> &'static Guid { &IID_IAgileObject } }

src/comptr.rs

@@ -1,7 +1,7 @@
 use std::ops::{Deref, DerefMut};
 use std::fmt;
 use std::ptr;
-use ::{ComIid, ComInterface, RtInterface, RtClassInterface, IInspectable, Guid};
+use crate::{ComIid, ComInterface, RtInterface, RtClassInterface, IInspectable, Guid};
 
 use w::shared::ntdef::VOID;
 use w::shared::minwindef::LPVOID;
@@ -38,7 +38,7 @@ pub fn query_interface<T, Target>(interface: &T) -> Option<ComPtr<Target>> where
 
 // This trait is not exported in the library interface
 pub trait HiddenGetRuntimeClassName {
-    fn get_runtime_class_name(&self) -> ::HString;
+    fn get_runtime_class_name(&self) -> crate::HString;
 }
 
 impl<T> ComPtr<T> {
@@ -80,7 +80,7 @@ impl<T> ComPtr<T> {
     /// This is a runtime no-op, but you need to be sure that the interface is compatible.
     #[inline]
     pub unsafe fn into_unchecked<Interface>(self) -> ComPtr<Interface> where Interface: ComInterface {
-        ::std::mem::transmute(self)
+        std::mem::transmute(self)
     }
 
     /// Gets the fully qualified name of the current Windows Runtime object.
@@ -100,7 +100,7 @@ impl<T> ComPtr<T> {
     /// assert_eq!("Windows.Foundation.Uri", uri.get_runtime_class_name().to_string());
     /// ```
     #[inline]
-    pub fn get_runtime_class_name(&self) -> ::HString where T: RtClassInterface {
+    pub fn get_runtime_class_name(&self) -> crate::HString where T: RtClassInterface {
         HiddenGetRuntimeClassName::get_runtime_class_name(self.as_inspectable())
     }
 
@@ -150,12 +150,12 @@ impl<T> PartialEq<ComPtr<T>> for ComPtr<T> {
 /// Owned array type that is used as return type when WinRT methods return arrays.
 /// It wraps a block of memory that has been allocated by WinRT and will be deallocated
 /// using `CoTaskMemFree` on drop.
-pub struct ComArray<T> where T: ::RtType {
+pub struct ComArray<T> where T: crate::RtType {
     size: u32,
     first: ptr::NonNull<T::Abi>
 }
 
-impl<T> ComArray<T> where T: ::RtType {
+impl<T> ComArray<T> where T: crate::RtType {
     #[inline]
     pub unsafe fn from_raw(size: u32, first: *mut T::Abi) -> ComArray<T> {
         assert!(!first.is_null());
@@ -172,25 +172,25 @@ impl<T> ComArray<T> where T: ::RtType {
     }
 }
 
-impl<T> Deref for ComArray<T> where T: ::RtType {
+impl<T> Deref for ComArray<T> where T: crate::RtType {
     type Target = [T::OutNonNull];
     #[inline]
     fn deref(&self) -> &[T::OutNonNull] {
-        unsafe { ::std::slice::from_raw_parts(self.first.as_ptr() as *mut T::OutNonNull, self.size as usize) }
+        unsafe { std::slice::from_raw_parts(self.first.as_ptr() as *mut T::OutNonNull, self.size as usize) }
     }
 }
-impl<T> DerefMut for ComArray<T> where T: ::RtType {
+impl<T> DerefMut for ComArray<T> where T: crate::RtType {
     #[inline]
     fn deref_mut(&mut self) -> &mut [T::OutNonNull] {
-        unsafe { ::std::slice::from_raw_parts_mut(self.first.as_ptr() as *mut T::OutNonNull, self.size as usize) }
+        unsafe { std::slice::from_raw_parts_mut(self.first.as_ptr() as *mut T::OutNonNull, self.size as usize) }
     }
 }
 
-impl<T> Drop for ComArray<T> where T: ::RtType {
+impl<T> Drop for ComArray<T> where T: crate::RtType {
     #[inline]
     fn drop(&mut self) {
         unsafe {
-            ::std::ptr::drop_in_place(&mut self[..]);
+            std::ptr::drop_in_place(&mut self[..]);
             CoTaskMemFree(self.first.as_ptr() as LPVOID)
         };
     }
@@ -201,8 +201,8 @@ mod extra {
     // i.e. when a compiler version is used that still has dropflags
     #[inline]
     fn assert_no_dropflags() {
-        let p: *mut ::IInspectable = ::std::ptr::null_mut();
-        let _: ::ComPtr<::IInspectable> = unsafe { ::std::mem::transmute(p) };
+        let p: *mut crate::IInspectable = std::ptr::null_mut();
+        let _: crate::ComPtr<crate::IInspectable> = unsafe { std::mem::transmute(p) };
     }
 }
 
@@ -212,10 +212,10 @@ mod tests {
 
     #[test]
     fn check_sizes() {
-        use ::std::mem::size_of;
+        use std::mem::size_of;
 
         // make sure that ComPtr is pointer-sized
-        assert_eq!(size_of::<::ComPtr<::IInspectable>>(), size_of::<*mut ::IInspectable>());
-        assert_eq!(size_of::<Option<::ComPtr<::IInspectable>>>(), size_of::<*mut ::IInspectable>());
+        assert_eq!(size_of::<crate::ComPtr<crate::IInspectable>>(), size_of::<*mut crate::IInspectable>());
+        assert_eq!(size_of::<Option<crate::ComPtr<crate::IInspectable>>>(), size_of::<*mut crate::IInspectable>());
     }
 }

src/guid.rs

@@ -50,8 +50,8 @@ mod tests {
 
     #[test]
     fn check_size() {
-        use ::std::mem::size_of;
+        use std::mem::size_of;
 
-        assert_eq!(size_of::<::Guid>(), size_of::<::w::shared::guiddef::GUID>());
+        assert_eq!(size_of::<crate::Guid>(), size_of::<w::shared::guiddef::GUID>());
     }
 }

src/hstring.rs

@@ -21,7 +21,7 @@ fn internal_to_string(hstr: HSTRING) -> String {
     unsafe {
         let mut len = 0;
         let buf = WindowsGetStringRawBuffer(hstr, &mut len);
-        let slice: &[u16] = ::std::slice::from_raw_parts(buf, len as usize);
+        let slice: &[u16] = std::slice::from_raw_parts(buf, len as usize);
         String::from_utf16_lossy(slice)
     }
 }
@@ -453,7 +453,7 @@ impl HString {
     pub fn make_reference<'a>(&'a self) -> HStringReference<'a> {
         let mut len = 0;
         let buf = unsafe { WindowsGetStringRawBuffer(self.0, &mut len) };
-        unsafe { HStringReference::from_utf16_unchecked(::std::slice::from_raw_parts(buf, len as usize + 1)) }
+        unsafe { HStringReference::from_utf16_unchecked(std::slice::from_raw_parts(buf, len as usize + 1)) }
     }
 }
 
@@ -467,7 +467,7 @@ impl Drop for HString {
 
 unsafe impl Send for HString {}
 
-impl ::std::clone::Clone for HString {
+impl std::clone::Clone for HString {
     #[inline]
     fn clone(&self) -> Self {
         let mut clone = HString::empty();
@@ -577,9 +577,9 @@ mod tests {
 
     #[test]
     fn check_sizes() {
-        use ::std::mem::size_of;
-        assert_eq!(size_of::<::HString>(), size_of::<::w::winrt::hstring::HSTRING>());
-        assert_eq!(size_of::<&::HStringArg>(), size_of::<::w::winrt::hstring::HSTRING>());
+        use std::mem::size_of;
+        assert_eq!(size_of::<crate::HString>(), size_of::<w::winrt::hstring::HSTRING>());
+        assert_eq!(size_of::<&crate::HStringArg>(), size_of::<w::winrt::hstring::HSTRING>());
     }
 
     #[test]