Migrate to the 2018 edition

Author: alexcrichton

Cargo.toml

@@ -12,6 +12,7 @@ A library to acquire a stack trace (backtrace) at runtime in a Rust program.
 """
 autoexamples = true
 autotests = true
+edition = "2018"
 
 [dependencies]
 cfg-if = "0.1.6"
@@ -22,8 +23,7 @@ core = { version = "1.0.0", optional = true, package = 'rustc-std-workspace-core
 compiler_builtins = { version = '0.1.2', optional = true }
 
 # Optionally enable the ability to serialize a `Backtrace`
-serde = { version = "1.0", optional = true }
-serde_derive = { version = "1.0", optional = true }
+serde = { version = "1.0", optional = true, features = ['derive'] }
 rustc-serialize = { version = "0.3", optional = true }
 
 # Optionally demangle C++ frames' symbols in backtraces.
@@ -37,9 +37,6 @@ memmap = { version = "0.7.0", optional = true }
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.3", optional = true }
 
-[build-dependencies]
-autocfg = "0.1"
-
 # Each feature controls the two phases of finding a backtrace: getting a
 # backtrace and then resolving instruction pointers to symbols. The default
 # feature enables all the necessary features for each platform this library
@@ -102,7 +99,7 @@ gimli-symbolize = ["addr2line", "findshlibs", "memmap" ]
 #
 # Various features used for enabling rustc-serialize or syntex codegen.
 serialize-rustc = ["rustc-serialize"]
-serialize-serde = ["serde", "serde_derive"]
+serialize-serde = ["serde"]
 
 #=======================================
 # Internal features for testing and such.

build.rs

@@ -21,12 +21,10 @@
 
 #![allow(bad_style)]
 
+use core::ffi::c_void;
 use core::mem;
-use core::prelude::v1::*;
-
-use dbghelp;
-use windows::*;
-use types::c_void;
+use crate::dbghelp;
+use crate::windows::*;
 
 #[derive(Clone, Copy)]
 pub enum Frame {

src/backtrace/dbghelp.rs

@@ -25,7 +25,7 @@
 //!
 //! This is the default unwinding API for all non-Windows platforms currently.
 
-use types::c_void;
+use core::ffi::c_void;
 
 pub enum Frame {
     Raw(*mut uw::_Unwind_Context),
@@ -94,7 +94,7 @@ pub unsafe fn trace(mut cb: &mut FnMut(&super::Frame) -> bool) {
             inner: Frame::Raw(ctx),
         };
 
-        let mut bomb = ::Bomb { enabled: true };
+        let mut bomb = crate::Bomb { enabled: true };
         let keep_going = cb(&cx);
         bomb.enabled = false;
 
@@ -117,8 +117,7 @@ pub unsafe fn trace(mut cb: &mut FnMut(&super::Frame) -> bool) {
 mod uw {
     pub use self::_Unwind_Reason_Code::*;
 
-    use libc;
-    use types::c_void;
+    use core::ffi::c_void;
 
     #[repr(C)]
     pub enum _Unwind_Reason_Code {

src/backtrace/libunwind.rs

@@ -1,5 +1,5 @@
 use core::fmt;
-use types::c_void;
+use core::ffi::c_void;
 
 /// Inspects the current call-stack, passing all active frames into the closure
 /// provided to calculate a stack trace.
@@ -49,7 +49,7 @@ use types::c_void;
 /// ```
 #[cfg(feature = "std")]
 pub fn trace<F: FnMut(&Frame) -> bool>(cb: F) {
-    let _guard = ::lock::lock();
+    let _guard = crate::lock::lock();
     unsafe { trace_unsynchronized(cb) }
 }
 
@@ -112,7 +112,7 @@ impl fmt::Debug for Frame {
     }
 }
 
-cfg_if! {
+cfg_if::cfg_if! {
     if #[cfg(
         any(
             all(

src/backtrace/mod.rs

@@ -1,7 +1,7 @@
 //! Empty implementation of unwinding used when no other implementation is
 //! appropriate.
 
-use types::c_void;
+use core::ffi::c_void;
 
 #[inline(always)]
 pub fn trace(_cb: &mut FnMut(&super::Frame) -> bool) {}

src/backtrace/noop.rs

@@ -16,11 +16,10 @@
 //! straightforward binding of the `backtrace` API to the `Frame` API that we'd
 //! like to have.
 
+use core::ffi::c_void;
 use core::mem;
 use libc::c_int;
 
-use types::c_void;
-
 #[derive(Clone)]
 pub struct Frame {
     addr: usize,

src/backtrace/unix_backtrace.rs

@@ -1,9 +1,11 @@
+use crate::{resolve, resolve_frame, trace, Symbol, SymbolName};
+use std::ffi::c_void;
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::prelude::v1::*;
 
-use types::c_void;
-use {resolve, resolve_frame, trace, Symbol, SymbolName};
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
 
 /// Representation of an owned and self-contained backtrace.
 ///
@@ -19,7 +21,7 @@ use {resolve, resolve_frame, trace, Symbol, SymbolName};
 /// enabled, and the `std` feature is enabled by default.
 #[derive(Clone)]
 #[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Backtrace {
     // Frames here are listed from top-to-bottom of the stack
     frames: Vec<BacktraceFrame>,
@@ -50,7 +52,7 @@ pub struct BacktraceFrame {
 
 #[derive(Clone)]
 enum Frame {
-    Raw(::Frame),
+    Raw(crate::Frame),
     #[allow(dead_code)]
     Deserialized {
         ip: usize,
@@ -85,7 +87,7 @@ impl Frame {
 /// enabled, and the `std` feature is enabled by default.
 #[derive(Clone)]
 #[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct BacktraceSymbol {
     name: Option<Vec<u8>>,
     addr: Option<usize>,
@@ -505,7 +507,7 @@ mod rustc_serialize_impls {
     }
 }
 
-#[cfg(feature = "serialize-serde")]
+#[cfg(feature = "serde")]
 mod serde_impls {
     extern crate serde;
 

src/capture.rs

@@ -25,7 +25,7 @@
 
 use core::mem;
 use core::ptr;
-use windows::*;
+use crate::windows::*;
 
 // Work around `SymGetOptions` and `SymSetOptions` not being present in winapi
 // itself. Otherwise this is only used when we're double-checking types against
@@ -36,7 +36,7 @@ mod dbghelp {
         StackWalk64, SymCleanup, SymFromAddrW, SymFunctionTableAccess64, SymGetLineFromAddrW64,
         SymGetModuleBase64, SymInitializeW,
     };
-    use windows::*;
+    use crate::windows::*;
 
     extern "system" {
         // Not defined in winapi yet

src/dbghelp.rs

@@ -73,48 +73,21 @@
 #[macro_use]
 extern crate std;
 
-extern crate libc;
-#[cfg(all(windows, feature = "verify-winapi"))]
-extern crate winapi;
-
-#[cfg(feature = "serde_derive")]
-#[cfg_attr(feature = "serde_derive", macro_use)]
-extern crate serde_derive;
-
-#[cfg(feature = "rustc-serialize")]
-extern crate rustc_serialize;
-
-#[macro_use]
-extern crate cfg_if;
-
-extern crate rustc_demangle;
-
-#[cfg(feature = "cpp_demangle")]
-extern crate cpp_demangle;
-
-cfg_if! {
-    if #[cfg(all(feature = "gimli-symbolize", unix, target_os = "linux"))] {
-        extern crate addr2line;
-        extern crate findshlibs;
-        extern crate memmap;
-    }
-}
-
-pub use backtrace::{trace_unsynchronized, Frame};
+pub use crate::backtrace::{trace_unsynchronized, Frame};
 mod backtrace;
 
-pub use symbolize::resolve_frame_unsynchronized;
-pub use symbolize::{resolve_unsynchronized, Symbol, SymbolName};
+pub use crate::symbolize::resolve_frame_unsynchronized;
+pub use crate::symbolize::{resolve_unsynchronized, Symbol, SymbolName};
 mod symbolize;
 
-pub use types::BytesOrWideString;
+pub use crate::types::BytesOrWideString;
 mod types;
 
-cfg_if! {
+cfg_if::cfg_if! {
     if #[cfg(feature = "std")] {
-        pub use backtrace::trace;
-        pub use symbolize::{resolve, resolve_frame};
-        pub use capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
+        pub use crate::backtrace::trace;
+        pub use crate::symbolize::{resolve, resolve_frame};
+        pub use crate::capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
         mod capture;
     }
 }

src/lib.rs

@@ -25,16 +25,15 @@
 
 #![allow(bad_style)]
 
+use crate::symbolize::dladdr;
+use crate::symbolize::ResolveWhat;
+use crate::types::BytesOrWideString;
+use crate::SymbolName;
+use core::ffi::c_void;
 use core::mem;
 use core::ptr;
 use core::slice;
-
-use libc::{self, c_char, c_int};
-
-use symbolize::ResolveWhat;
-use symbolize::dladdr;
-use types::{c_void, BytesOrWideString};
-use SymbolName;
+use libc::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq)]

src/symbolize/coresymbolication.rs

@@ -27,26 +27,17 @@
 
 #![allow(bad_style)]
 
-// This is a hack for compatibility with rustc 1.25.0. The no_std mode of this
-// crate is not supported pre-1.30.0, but in std mode the `char` module here
-// moved in rustc 1.26.0 (ish). As a result, in std mode we use `std::char` to
-// retain compatibility with rustc 1.25.0, but in `no_std` mode (which is
-// 1.30.0+ already) we use `core::char`.
-#[cfg(not(feature = "std"))]
+use crate::backtrace::FrameImp as Frame;
+use crate::dbghelp;
+use crate::symbolize::ResolveWhat;
+use crate::types::BytesOrWideString;
+use crate::windows::*;
+use crate::SymbolName;
 use core::char;
-#[cfg(feature = "std")]
-use std::char;
-
+use core::ffi::c_void;
 use core::mem;
 use core::slice;
 
-use backtrace::FrameImp as Frame;
-use dbghelp;
-use symbolize::ResolveWhat;
-use types::{c_void, BytesOrWideString};
-use windows::*;
-use SymbolName;
-
 // Store an OsString on std so we can provide the symbol name and filename.
 pub struct Symbol {
     name: *const [u8],

src/symbolize/dbghelp.rs

@@ -13,14 +13,14 @@
 
 #![allow(dead_code)]
 
-cfg_if! {
+cfg_if::cfg_if! {
     if #[cfg(all(unix, not(target_os = "emscripten"), feature = "dladdr"))] {
         use core::{mem, slice};
-
-        use types::{BytesOrWideString, c_void};
+        use crate::types::BytesOrWideString;
+        use core::ffi::c_void;
         use libc::{self, Dl_info};
 
-        use SymbolName;
+        use crate::SymbolName;
 
         pub struct Symbol {
             inner: Dl_info,
@@ -66,8 +66,9 @@ cfg_if! {
             }
         }
     } else {
-        use types::{BytesOrWideString, c_void};
-        use symbolize::SymbolName;
+        use core::ffi::c_void;
+        use crate::types::BytesOrWideString;
+        use crate::symbolize::SymbolName;
 
         pub enum Symbol {}
 

src/symbolize/dladdr.rs

@@ -14,8 +14,9 @@
 //! basic, not handling inline frame information at all. Since it's so prevalent
 //! though we have an option to use it!
 
-use types::{BytesOrWideString, c_void};
-use symbolize::{dladdr, SymbolName, ResolveWhat};
+use core::ffi::c_void;
+use crate::types::BytesOrWideString;
+use crate::symbolize::{dladdr, SymbolName, ResolveWhat};
 
 pub struct Symbol(dladdr::Symbol);
 

src/symbolize/dladdr_resolve.rs

@@ -4,6 +4,9 @@
 //! all platforms, but it's hoped to be developed over time! Long-term this is
 //! intended to wholesale replace the `libbacktrace.rs` implementation.
 
+use crate::symbolize::ResolveWhat;
+use crate::types::BytesOrWideString;
+use crate::SymbolName;
 use addr2line;
 use addr2line::object::{self, Object};
 use findshlibs::{self, Segment, SharedLibrary};
@@ -17,10 +20,6 @@ use std::path::{Path, PathBuf};
 use std::prelude::v1::*;
 use std::u32;
 
-use symbolize::ResolveWhat;
-use types::BytesOrWideString;
-use SymbolName;
-
 const MAPPINGS_CACHE_SIZE: usize = 4;
 
 type Dwarf = addr2line::Context;