Update log crate for better 2018 edition compatability

Change-Id: I653db9b4ad90812e91fe51a1da9d357dccbc2185
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index f0f20a4..bf5d85e 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -396,7 +396,7 @@
  "itertools 0.7.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.40 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "net2 0.2.32 (registry+https://github.com/rust-lang/crates.io-index)",
  "nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "num 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -614,12 +614,12 @@
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.1"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "cfg-if 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1550,7 +1550,7 @@
 "checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
 "checksum libc 0.2.40 (registry+https://github.com/rust-lang/crates.io-index)" = "6fd41f331ac7c5b8ac259b8bf82c75c0fb2e469bbf37d2becbba9a6a2221965b"
 "checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
-"checksum log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "89f010e843f2b1a31dbd316b3b8d443758bc634bed37aabade59c686d644e0a2"
+"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
 "checksum matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "100aabe6b8ff4e4a7e32c1c13523379802df0772b82466207ac25b013f193376"
 "checksum memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "148fab2e51b4f1cfc66da2a7c32981d1d3c083a803978268bb11fe4b86925e7a"
 "checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index 7c353f6..95f8b58 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -27,7 +27,7 @@
 itertools = "0.7"
 lazy_static = "0.1"
 libc = "0.2"
-log = { version = "0.4", features = ["std"] }
+log = { version = "0.4.4", features = ["std"] }
 net2 = "0.2"
 nom = "3.2"
 num = "0.1"
diff --git a/rustc_deps/vendor/log/.cargo-checksum.json b/rustc_deps/vendor/log/.cargo-checksum.json
index 3e4ab2a..55aab66 100644
--- a/rustc_deps/vendor/log/.cargo-checksum.json
+++ b/rustc_deps/vendor/log/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{".travis.yml":"8e95f3543ff36e1fd0e2e2fcc98b31e20dcc19d220f3d7d19bfb9aeb61030823","CHANGELOG.md":"cdfe104547fca9d80b95cff2c6ef5af7cdcd0a17886ec3722c157a598abec018","Cargo.toml":"ba13b382a64b910241ce4fc2ac4f45dd3a8f404f762f07958004a41de1cb55df","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"95873097578066ef6a0cc395f1aad5596762570ba1476757643fb319e3892481","appveyor.yml":"d5376a881aef6dc3bed6a6b51f1f1c3801b88fc77a12895f6953190256e965bc","src/lib.rs":"4ffa677655636a6c111026d318c92bb53bd91988e601fcdcdbe1f43b1997b8fd","src/macros.rs":"064c96e154b58b61b8a4f11cab9c0664dd171010f578af438fad0dc1d796ac5c","src/serde.rs":"7617ffa21dde363a06389f8e26661f35550c1a01ff142f81275e95f42b79c854","tests/filters.rs":"6aee024d4594b4fde772e35c5d3318e5aa5d9aa4eaeafb04e4c7c922be4ac837"},"package":"89f010e843f2b1a31dbd316b3b8d443758bc634bed37aabade59c686d644e0a2"}
\ No newline at end of file
+{"files":{".cargo_vcs_info.json":"25aebd6cce4993172e05e26454032cdc621acdf173687f2785263a6782f6f557",".travis.yml":"8e95f3543ff36e1fd0e2e2fcc98b31e20dcc19d220f3d7d19bfb9aeb61030823","CHANGELOG.md":"f201f429d849e6aaa5c3948770bf7fa29bc77358346a369a2a88cab0e8b76edb","Cargo.toml":"8f9b47fadc3b8250a3869e4bf4da63f6ccf4522bbd962ad5c39be9d072189d5e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"224146f378b819f78b735156c93002d81dd9d1998b221bf26ca2bca04223f29e","appveyor.yml":"d5376a881aef6dc3bed6a6b51f1f1c3801b88fc77a12895f6953190256e965bc","src/lib.rs":"a6590c47262193de32b762330694cd97bc68d0a29840ae86f5fb55c88e12e960","src/macros.rs":"2d180878886c945c6f3a11f556a84c7cef86f6743eaf7063b343754f8aab09d0","src/serde.rs":"a5ae50d6f5ac538a5ca57ee58031a2582afa6989c741574584756632a4131ba7","tests/filters.rs":"6aee024d4594b4fde772e35c5d3318e5aa5d9aa4eaeafb04e4c7c922be4ac837"},"package":"d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/log/.cargo_vcs_info.json b/rustc_deps/vendor/log/.cargo_vcs_info.json
new file mode 100644
index 0000000..d7fe5cb
--- /dev/null
+++ b/rustc_deps/vendor/log/.cargo_vcs_info.json
@@ -0,0 +1,5 @@
+{
+  "git": {
+    "sha1": "d711a6bf4891aedbafddad684b6b42ddc5193c51"
+  }
+}
diff --git a/rustc_deps/vendor/log/CHANGELOG.md b/rustc_deps/vendor/log/CHANGELOG.md
index b26b418..e645f00 100644
--- a/rustc_deps/vendor/log/CHANGELOG.md
+++ b/rustc_deps/vendor/log/CHANGELOG.md
@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.4.5] - 2018-09-03
+
+### Improved
+
+* Make `log`'s internal helper macros less likely to conflict with user-defined
+  macros.
+
+## [0.4.4] - 2018-08-17
+
+### Improved
+
+* Support 2018-style imports of the log macros.
+
+## [0.4.3] - 2018-06-29
+
+### Improved
+
+* More code generation improvements.
+
+## [0.4.2] - 2018-06-05
+
+### Improved
+
+* Log invocations now generate less code.
+
+### Fixed
+
+* Example Logger implementations now properly set the max log level.
+
 ## [0.4.1] - 2017-12-30
 
 ### Fixed
@@ -77,7 +106,11 @@
 
 Look at the [release tags] for information about older releases.
 
-[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.1...HEAD
+[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.5...HEAD
+[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.4...0.4.5
+[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.3...0.4.4
+[0.4.3]: https://github.com/rust-lang-nursery/log/compare/0.4.2...0.4.3
+[0.4.2]: https://github.com/rust-lang-nursery/log/compare/0.4.1...0.4.2
 [0.4.1]: https://github.com/rust-lang-nursery/log/compare/0.4.0...0.4.1
 [0.4.0]: https://github.com/rust-lang-nursery/log/compare/0.3.8...0.4.0
 [release tags]: https://github.com/rust-lang-nursery/log/releases
diff --git a/rustc_deps/vendor/log/Cargo.toml b/rustc_deps/vendor/log/Cargo.toml
index 510a771..66a5c17 100644
--- a/rustc_deps/vendor/log/Cargo.toml
+++ b/rustc_deps/vendor/log/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "log"
-version = "0.4.1"
+version = "0.4.5"
 authors = ["The Rust Project Developers"]
 description = "A lightweight logging facade for Rust\n"
 homepage = "https://github.com/rust-lang/log"
diff --git a/rustc_deps/vendor/log/README.md b/rustc_deps/vendor/log/README.md
index c1c2dbf..cb04a68 100644
--- a/rustc_deps/vendor/log/README.md
+++ b/rustc_deps/vendor/log/README.md
@@ -5,6 +5,9 @@
 
 [![Build Status](https://travis-ci.org/rust-lang-nursery/log.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/log)
 [![Build status](https://ci.appveyor.com/api/projects/status/nopdjmmjt45xcrki?svg=true)](https://ci.appveyor.com/project/alexcrichton/log)
+[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
+[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
+![License](https://img.shields.io/crates/l/log.svg)
 
 * [`log` documentation](https://docs.rs/log)
 
@@ -29,7 +32,7 @@
 #[macro_use]
 extern crate log;
 
-pub fn shave_the_yak(yak: &Yak) {
+pub fn shave_the_yak(yak: &mut Yak) {
     trace!("Commencing yak shaving");
 
     loop {
@@ -65,6 +68,7 @@
 * Adaptors for other facilities:
     * [`syslog`](https://docs.rs/syslog/*/syslog/)
     * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
+    * [`android_log`](https://docs.rs/android_log/*/android_log/)
 
 Executables should choose a logger implementation and initialize it early in the
 runtime of the program. Logger implementations will typically include a
diff --git a/rustc_deps/vendor/log/src/lib.rs b/rustc_deps/vendor/log/src/lib.rs
index e68cf40..7d89139 100644
--- a/rustc_deps/vendor/log/src/lib.rs
+++ b/rustc_deps/vendor/log/src/lib.rs
@@ -28,8 +28,9 @@
 //!
 //! The basic use of the log crate is through the five logging macros: [`error!`],
 //! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
-//! where `error!` represents the highest-priority log level, and `trace!` the lowest.
-//!
+//! where `error!` represents the highest-priority log messages
+//! and `trace!` the lowest. The log messages are filtered by configuring
+//! the log level to exclude messages with a lower priority.
 //! Each of these macros accept format strings similarly to [`println!`].
 //!
 //!
@@ -53,9 +54,9 @@
 //! extern crate log;
 //!
 //! # #[derive(Debug)] pub struct Yak(String);
-//! # impl Yak { fn shave(&self, _: u32) {} }
+//! # impl Yak { fn shave(&mut self, _: u32) {} }
 //! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
-//! pub fn shave_the_yak(yak: &Yak) {
+//! pub fn shave_the_yak(yak: &mut Yak) {
 //!     info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);
 //!
 //!     loop {
@@ -138,16 +139,16 @@
 //! # fn main() {}
 //! ```
 //!
-//! Loggers are installed by calling the [`set_logger`] function. It takes a
-//! closure which is provided a [`MaxLevelFilter`] token and returns a
-//! [`Log`] trait object. The [`MaxLevelFilter`] token controls the global
-//! maximum log level. The logging facade uses this as an optimization to
-//! improve performance of log messages at levels that are disabled. In the
-//! case of our example logger, we'll want to set the maximum log level to
-//! [`Info`][level_link], since we ignore any [`Debug`][level_link] or
-//! [`Trace`][level_link] level log messages. A logging implementation
-//! should provide a function that wraps a call to [`set_logger`], handling
-//! initialization of the logger:
+//! Loggers are installed by calling the [`set_logger`] function. The maximum
+//! log level also needs to be adjusted via the [`set_max_level`] function. The
+//! logging facade uses this as an optimization to improve performance of log
+//! messages at levels that are disabled. It's important to set it, as it
+//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
+//! In the case of our example logger, we'll want to set the maximum log level
+//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
+//! [`Trace`][level_link] level log messages. A logging implementation should
+//! provide a function that wraps a call to [`set_logger`] and
+//! [`set_max_level`], handling initialization of the logger:
 //!
 //! ```rust
 //! # extern crate log;
@@ -165,16 +166,20 @@
 //!
 //! pub fn init() -> Result<(), SetLoggerError> {
 //!     log::set_logger(&LOGGER)
+//!         .map(|()| log::set_max_level(LevelFilter::Info))
 //! }
 //! ```
 //!
+//! Implementations that adjust their configurations at runtime should take care
+//! to adjust the maximum log level as well.
+//!
 //! # Use with `std`
 //!
-//! `set_logger` requires you to provide a `&'static Log`, which can be hard if
-//! your logger depends on some runtime configuration. The `set_boxed_logger`
-//! function is available with the `std` Cargo feature. It is identical to
-//! `set_logger` except that it requires you to provide a `Box<Log>` rather than
-//! a `&'static Log`:
+//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
+//! obtain if your logger depends on some runtime configuration. The
+//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
+//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
+//! `&'static Log`:
 //!
 //! ```rust
 //! # extern crate log;
@@ -189,6 +194,7 @@
 //! # #[cfg(feature = "std")]
 //! pub fn init() -> Result<(), SetLoggerError> {
 //!     log::set_boxed_logger(Box::new(SimpleLogger))
+//!         .map(|()| log::set_max_level(LevelFilter::Info))
 //! }
 //! ```
 //!
@@ -215,13 +221,26 @@
 //! These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros check
 //! this value before logging a message. By default, no levels are disabled.
 //!
-//! For example, a crate can disable trace level logs in debug builds and trace, info, and warn
+//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
 //! level logs in release builds with the following configuration:
 //!
 //! ```toml
 //! [dependencies]
 //! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
 //! ```
+//! # Crate Feature Flags
+//!
+//! The following crate feature flags are avaliable in addition to the filters. They are
+//! configured in your `Cargo.toml`.
+//!
+//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
+//! `set_boxed_logger` functionality.
+//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
+//!
+//! ```toml
+//! [dependencies]
+//! log = { version = "0.4", features = ["std", "serde"] }
+//! ```
 //!
 //! # Version compatibility
 //!
@@ -232,8 +251,9 @@
 //!
 //! [`Log`]: trait.Log.html
 //! [level_link]: enum.Level.html
+//! [filter_link]: enum.LevelFilter.html
 //! [`set_logger`]: fn.set_logger.html
-//! [`MaxLevelFilter`]: struct.MaxLevelFilter.html
+//! [`set_max_level`]: fn.set_max_level.html
 //! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
 //! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
 //! [env_logger]: https://docs.rs/env_logger/*/env_logger/
@@ -247,14 +267,14 @@
 //! [log4rs]: https://docs.rs/log4rs/*/log4rs/
 //! [fern]: https://docs.rs/fern/*/fern/
 
-#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
-       html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-       html_root_url = "https://docs.rs/log/0.4.1")]
+#![doc(
+    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+    html_root_url = "https://docs.rs/log/0.4.5"
+)]
 #![warn(missing_docs)]
 #![deny(missing_debug_implementations)]
-
 #![cfg_attr(not(feature = "std"), no_std)]
-
 // When compiled for the rustc compiler itself we want to make sure that this is
 // an unstable crate
 #![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
@@ -272,7 +292,7 @@
 use std::fmt;
 use std::mem;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
+use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 
 #[macro_use]
 mod macros;
@@ -294,10 +314,10 @@
 
 static LOG_LEVEL_NAMES: [&'static str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
 
-static SET_LOGGER_ERROR: &'static str = "attempted to set a logger after the logging system was \
-    already initialized";
-static LEVEL_PARSE_ERROR: &'static str = "attempted to convert a string that doesn't match an \
-    existing log level";
+static SET_LOGGER_ERROR: &'static str = "attempted to set a logger after the logging system \
+                                         was already initialized";
+static LEVEL_PARSE_ERROR: &'static str =
+    "attempted to convert a string that doesn't match an existing log level";
 
 /// An enum representing the available verbosity levels of the logger.
 ///
@@ -356,6 +376,26 @@
     fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
         Some(self.cmp(other))
     }
+
+    #[inline]
+    fn lt(&self, other: &Level) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &Level) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &Level) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &Level) -> bool {
+        *self as usize >= *other as usize
+    }
 }
 
 impl PartialOrd<LevelFilter> for Level {
@@ -363,6 +403,26 @@
     fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
         Some((*self as usize).cmp(&(*other as usize)))
     }
+
+    #[inline]
+    fn lt(&self, other: &LevelFilter) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &LevelFilter) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &LevelFilter) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &LevelFilter) -> bool {
+        *self as usize >= *other as usize
+    }
 }
 
 impl Ord for Level {
@@ -390,9 +450,9 @@
     }
 
     if a.len() == b.len() {
-        a.bytes().zip(b.bytes()).all(|(a, b)| {
-            to_ascii_uppercase(a) == to_ascii_uppercase(b)
-        })
+        a.bytes()
+            .zip(b.bytes())
+            .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b))
     } else {
         false
     }
@@ -498,12 +558,52 @@
     fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
         Some(self.cmp(other))
     }
+
+    #[inline]
+    fn lt(&self, other: &LevelFilter) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &LevelFilter) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &LevelFilter) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &LevelFilter) -> bool {
+        *self as usize >= *other as usize
+    }
 }
 
 impl PartialOrd<Level> for LevelFilter {
     #[inline]
     fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
-        other.partial_cmp(self).map(|x| x.reverse())
+        Some((*self as usize).cmp(&(*other as usize)))
+    }
+
+    #[inline]
+    fn lt(&self, other: &Level) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &Level) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &Level) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &Level) -> bool {
+        *self as usize >= *other as usize
     }
 }
 
@@ -1048,16 +1148,21 @@
 
 fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
 where
-    F: FnOnce() -> &'static Log
+    F: FnOnce() -> &'static Log,
 {
     unsafe {
-        if STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, Ordering::SeqCst) != UNINITIALIZED {
-            return Err(SetLoggerError(()));
+        match STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, Ordering::SeqCst) {
+            UNINITIALIZED => {
+                LOGGER = make_logger();
+                STATE.store(INITIALIZED, Ordering::SeqCst);
+                Ok(())
+            }
+            INITIALIZING => {
+                while STATE.load(Ordering::SeqCst) == INITIALIZING {}
+                Err(SetLoggerError(()))
+            }
+            _ => Err(SetLoggerError(())),
         }
-
-        LOGGER = make_logger();
-        STATE.store(INITIALIZED, Ordering::SeqCst);
-        Ok(())
     }
 }
 
@@ -1117,6 +1222,31 @@
     }
 }
 
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_log(
+    args: fmt::Arguments,
+    level: Level,
+    &(target, module_path, file, line): &(&str, &str, &str, u32),
+) {
+    logger().log(
+        &Record::builder()
+            .args(args)
+            .level(level)
+            .target(target)
+            .module_path(Some(module_path))
+            .file(Some(file))
+            .line(Some(line))
+            .build(),
+    );
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_enabled(level: Level, target: &str) -> bool {
+    logger().enabled(&Metadata::builder().level(level).target(target).build())
+}
+
 /// The statically resolved maximum log level.
 ///
 /// See the crate level documentation for information on how to configure this.
@@ -1159,8 +1289,8 @@
 #[cfg(test)]
 mod tests {
     extern crate std;
-    use tests::std::string::ToString;
     use super::{Level, LevelFilter, ParseLevelError};
+    use tests::std::string::ToString;
 
     #[test]
     fn test_levelfilter_from_str() {
@@ -1247,13 +1377,13 @@
     #[test]
     #[cfg(feature = "std")]
     fn test_error_trait() {
-        use std::error::Error;
         use super::SetLoggerError;
+        use std::error::Error;
         let e = SetLoggerError(());
         assert_eq!(
             e.description(),
             "attempted to set a logger after the logging system \
-                     was already initialized"
+             was already initialized"
         );
     }
 
@@ -1321,7 +1451,7 @@
 
     #[test]
     fn test_record_complete_builder() {
-        use super::{Record, Level};
+        use super::{Level, Record};
         let target = "myApp";
         let record_test = Record::builder()
             .module_path(Some("foo"))
diff --git a/rustc_deps/vendor/log/src/macros.rs b/rustc_deps/vendor/log/src/macros.rs
index 25f697f..3fc858e 100644
--- a/rustc_deps/vendor/log/src/macros.rs
+++ b/rustc_deps/vendor/log/src/macros.rs
@@ -29,25 +29,19 @@
 ///     data.0, data.1, private_data);
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! log {
     (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
         let lvl = $lvl;
         if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
-            $crate::Log::log(
-                $crate::logger(),
-                &$crate::RecordBuilder::new()
-                    .args(format_args!($($arg)+))
-                    .level(lvl)
-                    .target($target)
-                    .module_path(Some(module_path!()))
-                    .file(Some(file!()))
-                    .line(Some(line!()))
-                    .build()
-            )
+            $crate::__private_api_log(
+                __log_format_args!($($arg)+),
+                lvl,
+                &($target, __log_module_path!(), __log_file!(), __log_line!()),
+            );
         }
     });
-    ($lvl:expr, $($arg:tt)+) => (log!(target: module_path!(), $lvl, $($arg)+))
+    ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+))
 }
 
 /// Logs a message at the error level.
@@ -64,7 +58,7 @@
 /// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! error {
     (target: $target:expr, $($arg:tt)*) => (
         log!(target: $target, $crate::Level::Error, $($arg)*);
@@ -88,7 +82,7 @@
 /// warn!(target: "input_events", "App received warning: {}", warn_description);
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! warn {
     (target: $target:expr, $($arg:tt)*) => (
         log!(target: $target, $crate::Level::Warn, $($arg)*);
@@ -114,7 +108,7 @@
 ///       conn_info.port, conn_info.speed);
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! info {
     (target: $target:expr, $($arg:tt)*) => (
         log!(target: $target, $crate::Level::Info, $($arg)*);
@@ -139,7 +133,7 @@
 /// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! debug {
     (target: $target:expr, $($arg:tt)*) => (
         log!(target: $target, $crate::Level::Debug, $($arg)*);
@@ -166,7 +160,7 @@
 ///        if pos.y >= 0.0 { "positive" } else { "negative" });
 /// # }
 /// ```
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! trace {
     (target: $target:expr, $($arg:tt)*) => (
         log!(target: $target, $crate::Level::Trace, $($arg)*);
@@ -205,16 +199,55 @@
 /// ```
 #[macro_export]
 macro_rules! log_enabled {
-    (target: $target:expr, $lvl:expr) => ({
+    (target: $target:expr, $lvl:expr) => {{
         let lvl = $lvl;
-        lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() &&
-            $crate::Log::enabled(
-                $crate::logger(),
-                &$crate::MetadataBuilder::new()
-                    .level(lvl)
-                    .target($target)
-                    .build(),
-            )
-    });
-    ($lvl:expr) => (log_enabled!(target: module_path!(), $lvl))
+        lvl <= $crate::STATIC_MAX_LEVEL
+            && lvl <= $crate::max_level()
+            && $crate::__private_api_enabled(lvl, $target)
+    }};
+    ($lvl:expr) => {
+        log_enabled!(target: __log_module_path!(), $lvl)
+    };
+}
+
+// The log macro above cannot invoke format_args directly because it uses
+// local_inner_macros. A format_args invocation there would resolve to
+// $crate::format_args which does not exist. Instead invoke format_args here
+// outside of local_inner_macros so that it resolves (probably) to
+// core::format_args or std::format_args. Same for the several macros that
+// follow.
+//
+// This is a workaround until we drop support for pre-1.30 compilers. At that
+// point we can remove use of local_inner_macros, use $crate:: when invoking
+// local macros, and invoke format_args directly.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_format_args {
+    ($($args:tt)*) => {
+        format_args!($($args)*)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_module_path {
+    () => {
+        module_path!()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_file {
+    () => {
+        file!()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_line {
+    () => {
+        line!()
+    };
 }
diff --git a/rustc_deps/vendor/log/src/serde.rs b/rustc_deps/vendor/log/src/serde.rs
index 4b9afa5..176f9f4 100644
--- a/rustc_deps/vendor/log/src/serde.rs
+++ b/rustc_deps/vendor/log/src/serde.rs
@@ -3,12 +3,12 @@
 extern crate serde;
 use self::serde::ser::{Serialize, Serializer};
 use self::serde::de::{Deserialize, DeserializeSeed, Deserializer, Visitor, EnumAccess,
-                      VariantAccess, Error};
+                      Unexpected, VariantAccess, Error};
 
 use {Level, LevelFilter, LOG_LEVEL_NAMES};
 
 use std::fmt;
-use std::str::FromStr;
+use std::str::{self, FromStr};
 
 // The Deserialize impls are handwritten to be case insensitive using FromStr.
 
@@ -48,6 +48,16 @@
                 // Case insensitive.
                 FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
             }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = str::from_utf8(value)
+                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+                self.visit_str(variant)
+            }
         }
 
         impl<'de> DeserializeSeed<'de> for LevelIdentifier {
@@ -122,6 +132,16 @@
                 // Case insensitive.
                 FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
             }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = str::from_utf8(value)
+                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+                self.visit_str(variant)
+            }
         }
 
         impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
@@ -162,7 +182,7 @@
 #[cfg(test)]
 mod tests {
     extern crate serde_test;
-    use self::serde_test::{Token, assert_tokens, assert_de_tokens, assert_de_tokens_error};
+    use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
 
     use {Level, LevelFilter};
 
@@ -173,6 +193,14 @@
         }
     }
 
+    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+        [
+            Token::Enum { name: "Level" },
+            Token::Bytes(variant),
+            Token::Unit,
+        ]
+    }
+
     fn level_filter_token(variant: &'static str) -> Token {
         Token::UnitVariant {
             name: "LevelFilter",
@@ -180,6 +208,16 @@
         }
     }
 
+    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+        [
+            Token::Enum {
+                name: "LevelFilter",
+            },
+            Token::Bytes(variant),
+            Token::Unit,
+        ]
+    }
+
     #[test]
     fn test_level_ser_de() {
         let cases = [
@@ -211,6 +249,21 @@
     }
 
     #[test]
+    fn test_level_de_bytes() {
+        let cases = [
+            (Level::Error, level_bytes_tokens(b"ERROR")),
+            (Level::Warn, level_bytes_tokens(b"WARN")),
+            (Level::Info, level_bytes_tokens(b"INFO")),
+            (Level::Debug, level_bytes_tokens(b"DEBUG")),
+            (Level::Trace, level_bytes_tokens(b"TRACE")),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
     fn test_level_de_error() {
         let msg = "unknown variant `errorx`, expected one of \
                    `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
@@ -250,6 +303,22 @@
     }
 
     #[test]
+    fn test_level_filter_de_bytes() {
+        let cases = [
+            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
+            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
+            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
+            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
+            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
+            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
     fn test_level_filter_de_error() {
         let msg = "unknown variant `errorx`, expected one of \
                    `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";