Update readme/misc

Author: alexcrichton

README.md

@@ -14,18 +14,12 @@ backtrace like libstd's panics.
 backtrace = "0.3"
 ```
 
-Note that this crate requires `cc` and `ar` to be present on Unix systems when
-`libbacktrace` is used (which is the default). For configuring C compilers see
-the [`cc` crate documentation](https://github.com/alexcrichton/cc-rs).
-
 ## Usage
 
 To simply capture a backtrace and defer dealing with it until a later time,
 you can use the top-level `Backtrace` type.
 
 ```rust
-extern crate backtrace;
-
 use backtrace::Backtrace;
 
 fn main() {
@@ -41,8 +35,6 @@ If, however, you'd like more raw access to the actual tracing functionality, you
 can use the `trace` and `resolve` functions directly.
 
 ```rust
-extern crate backtrace;
-
 fn main() {
     backtrace::trace(|frame| {
         let ip = frame.ip();

src/backtrace/libunwind.rs

@@ -82,14 +82,14 @@ impl Clone for Frame {
 }
 
 #[inline(always)]
-pub unsafe fn trace(mut cb: &mut FnMut(&super::Frame) -> bool) {
+pub unsafe fn trace(mut cb: &mut dyn FnMut(&super::Frame) -> bool) {
     uw::_Unwind_Backtrace(trace_fn, &mut cb as *mut _ as *mut _);
 
     extern "C" fn trace_fn(
         ctx: *mut uw::_Unwind_Context,
         arg: *mut c_void,
     ) -> uw::_Unwind_Reason_Code {
-        let cb = unsafe { &mut *(arg as *mut &mut FnMut(&super::Frame) -> bool) };
+        let cb = unsafe { &mut *(arg as *mut &mut dyn FnMut(&super::Frame) -> bool) };
         let cx = super::Frame {
             inner: Frame::Raw(ctx),
         };

src/lib.rs

@@ -6,25 +6,6 @@
 //! parsed, for example, and expose the functionality of multiple backend
 //! implementations.
 //!
-//! # Implementation
-//!
-//! This library makes use of a number of strategies for actually acquiring a
-//! backtrace. For example unix uses libgcc's libunwind bindings by default to
-//! acquire a backtrace, but coresymbolication or dladdr is used on OSX to
-//! acquire symbol names while linux uses gcc's libbacktrace.
-//!
-//! When using the default feature set of this library the "most reasonable" set
-//! of defaults is chosen for the current platform, but the features activated
-//! can also be controlled at a finer granularity.
-//!
-//! # API Principles
-//!
-//! This library attempts to be as flexible as possible to accommodate different
-//! backend implementations of acquiring a backtrace. Consequently the currently
-//! exported functions are closure-based as opposed to the likely expected
-//! iterator-based versions. This is done due to limitations of the underlying
-//! APIs used from the system.
-//!
 //! # Usage
 //!
 //! First, add this to your Cargo.toml
@@ -37,8 +18,6 @@
 //! Next:
 //!
 //! ```
-//! extern crate backtrace;
-//!
 //! fn main() {
 //! # // Unsafe here so test passes on no_std.
 //! # #[cfg(feature = "std")] {
@@ -69,8 +48,6 @@
     all(feature = "std", target_env = "sgx", target_vendor = "fortanix"),
     feature(sgx_platform)
 )]
-#![allow(bare_trait_objects)] // TODO: remove when updating to 2018 edition
-#![allow(rust_2018_idioms)] // TODO: remove when updating to 2018 edition
 
 #[cfg(feature = "std")]
 #[macro_use]

src/print.rs

@@ -16,7 +16,7 @@ pub struct BacktraceFmt<'a, 'b> {
     fmt: &'a mut fmt::Formatter<'b>,
     frame_index: usize,
     format: PrintFmt,
-    print_path: &'a mut (FnMut(&mut fmt::Formatter, BytesOrWideString) -> fmt::Result + 'b),
+    print_path: &'a mut (dyn FnMut(&mut fmt::Formatter, BytesOrWideString) -> fmt::Result + 'b),
 }
 
 /// The styles of printing that we can print
@@ -41,7 +41,7 @@ impl<'a, 'b> BacktraceFmt<'a, 'b> {
     pub fn new(
         fmt: &'a mut fmt::Formatter<'b>,
         format: PrintFmt,
-        print_path: &'a mut (FnMut(&mut fmt::Formatter, BytesOrWideString) -> fmt::Result + 'b),
+        print_path: &'a mut (dyn FnMut(&mut fmt::Formatter, BytesOrWideString) -> fmt::Result + 'b),
     ) -> Self {
         BacktraceFmt {
             fmt,

src/symbolize/gimli.rs

@@ -459,7 +459,7 @@ impl Cache {
     }
 }
 
-pub unsafe fn resolve(what: ResolveWhat, cb: &mut FnMut(&super::Symbol)) {
+pub unsafe fn resolve(what: ResolveWhat, cb: &mut dyn FnMut(&super::Symbol)) {
     let addr = what.address_or_ip();
     let mut call = |sym: Symbol| {
         // Extend the lifetime of `sym` to `'static` since we are unfortunately