Update from rust-lang/rust/master 2020-04-14

Cargo.lock

@@ -94,6 +94,12 @@ dependencies = [
  "nodrop",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
+
 [[package]]
 name = "atty"
 version = "0.2.14"
@@ -164,7 +170,7 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d6d530bdd2d52966a6d03b7a964add7ae1a288d25214066fd4b600f0f796400"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.4.7",
  "constant_time_eq",
 ]
 
@@ -714,7 +720,7 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fedcd6772e37f3da2a9af9bf12ebe046c0dfe657992377b4df982a2b54cd37a9"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.4.7",
  "cfg-if",
  "crossbeam-utils 0.6.5",
  "lazy_static",
@@ -3494,8 +3500,8 @@ dependencies = [
 name = "rustc_index"
 version = "0.0.0"
 dependencies = [
+ "arrayvec 0.5.1",
  "rustc_serialize",
- "smallvec 1.4.0",
 ]
 
 [[package]]
@@ -3996,6 +4002,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hir",
+ "rustc_hir_pretty",
  "rustc_index",
  "rustc_infer",
  "rustc_middle",

RELEASES.md

@@ -1,3 +1,166 @@
+Version 1.45.0 (2020-07-16)
+==========================
+
+Language
+--------
+- [Out of range float to int conversions using `as` has been defined as a saturating
+  conversion.][71269] This was previously undefined behaviour, but you can use the
+   `{f64, f32}::to_int_unchecked` methods to continue using the current behaviour, which
+   may be desirable in rare performance sensitive situations.
+- [`mem::Discriminant<T>` now uses `T`'s discriminant type instead of always
+  using `u64`.][70705]
+- [Function like procedural macros can now be used in expression, pattern, and  statement
+  positions.][68717] This means you can now use a function-like procedural macro
+  anywhere you can use a declarative (`macro_rules!`) macro.
+
+Compiler
+--------
+- [You can now override individual target features through the `target-feature`
+  flag.][72094] E.g. `-C target-feature=+avx2 -C target-feature=+fma` is now
+  equivalent to `-C target-feature=+avx2,+fma`.
+- [Added the `force-unwind-tables` flag.][69984] This option allows
+  rustc to always generate unwind tables regardless of panic strategy.
+- [Added the `embed-bitcode` flag.][71716] This codegen flag allows rustc
+  to include LLVM bitcode into generated `rlib`s (this is on by default).
+- [Added the `tiny` value to the `code-model` codegen flag.][72397]
+- [Added tier 3 support\* for the `mipsel-sony-psp` target.][72062]
+- [Added tier 3 support for the `thumbv7a-uwp-windows-msvc` target.][72133]
+
+\* Refer to Rust's [platform support page][forge-platform-support] for more
+information on Rust's tiered platform support.
+
+
+Libraries
+---------
+- [`net::{SocketAddr, SocketAddrV4, SocketAddrV6}` now implements `PartialOrd`
+  and `Ord`.][72239]
+- [`proc_macro::TokenStream` now implements `Default`.][72234]
+- [You can now use `char` with
+  `ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo}` to iterate over
+  a range of codepoints.][72413] E.g.
+  you can now write the following;
+  ```rust
+  for ch in 'a'..='z' {
+      print!("{}", ch);
+  }
+  println!();
+  // Prints "abcdefghijklmnopqrstuvwxyz"
+  ```
+- [`OsString` now implements `FromStr`.][71662]
+- [The `saturating_neg` method as been added to all signed integer primitive
+  types, and the `saturating_abs` method has been added for all integer
+  primitive types.][71886]
+- [`Arc<T>`, `Rc<T>` now implement  `From<Cow<'_, T>>`, and `Box` now
+  implements `From<Cow>` when `T` is `[T: Copy]`, `str`, `CStr`, `OsStr`,
+  or `Path`.][71447]
+- [`Box<[T]>` now implements `From<[T; N]>`.][71095]
+- [`BitOr` and `BitOrAssign` are implemented for all `NonZero`
+  integer types.][69813]
+- [The `fetch_min`, and `fetch_max` methods have been added to all atomic
+  integer types.][72324]
+- [The `fetch_update` method has been added to all atomic integer types.][71843]
+
+Stabilized APIs
+---------------
+- [`Arc::as_ptr`]
+- [`BTreeMap::remove_entry`]
+- [`Rc::as_ptr`]
+- [`rc::Weak::as_ptr`]
+- [`rc::Weak::from_raw`]
+- [`rc::Weak::into_raw`]
+- [`str::strip_prefix`]
+- [`str::strip_suffix`]
+- [`sync::Weak::as_ptr`]
+- [`sync::Weak::from_raw`]
+- [`sync::Weak::into_raw`]
+- [`char::UNICODE_VERSION`]
+- [`Span::resolved_at`]
+- [`Span::located_at`]
+- [`Span::mixed_site`]
+- [`unix::process::CommandExt::arg0`]
+
+Cargo
+-----
+
+Misc
+----
+- [Rustdoc now supports strikethrough text in Markdown.][71928] E.g.
+  `~~outdated information~~` becomes "~~outdated information~~".
+- [Added an emoji to Rustdoc's deprecated API message.][72014]
+
+Compatibility Notes
+-------------------
+- [Trying to self initialize a static value (that is creating a value using
+  itself) is unsound and now causes a compile error.][71140]
+- [`{f32, f64}::powi` now returns a slightly different value on Windows.][73420]
+  This is due to changes in LLVM's intrinsics which `{f32, f64}::powi` uses.
+- [Rustdoc's CLI's extra error exit codes have been removed.][71900] These were
+  previously undocumented and not intended for public use. Rustdoc still provides
+  a non-zero exit code on errors.
+
+Internals Only
+--------------
+- [Make clippy a git subtree instead of a git submodule][70655]
+- [Unify the undo log of all snapshot types][69464]
+
+[73420]: https://github.com/rust-lang/rust/issues/73420/
+[72324]: https://github.com/rust-lang/rust/pull/72324/
+[71843]: https://github.com/rust-lang/rust/pull/71843/
+[71886]: https://github.com/rust-lang/rust/pull/71886/
+[72234]: https://github.com/rust-lang/rust/pull/72234/
+[72239]: https://github.com/rust-lang/rust/pull/72239/
+[72397]: https://github.com/rust-lang/rust/pull/72397/
+[72413]: https://github.com/rust-lang/rust/pull/72413/
+[72014]: https://github.com/rust-lang/rust/pull/72014/
+[72062]: https://github.com/rust-lang/rust/pull/72062/
+[72094]: https://github.com/rust-lang/rust/pull/72094/
+[72133]: https://github.com/rust-lang/rust/pull/72133/
+[71900]: https://github.com/rust-lang/rust/pull/71900/
+[71928]: https://github.com/rust-lang/rust/pull/71928/
+[71662]: https://github.com/rust-lang/rust/pull/71662/
+[71716]: https://github.com/rust-lang/rust/pull/71716/
+[71447]: https://github.com/rust-lang/rust/pull/71447/
+[71269]: https://github.com/rust-lang/rust/pull/71269/
+[71095]: https://github.com/rust-lang/rust/pull/71095/
+[71140]: https://github.com/rust-lang/rust/pull/71140/
+[70655]: https://github.com/rust-lang/rust/pull/70655/
+[70705]: https://github.com/rust-lang/rust/pull/70705/
+[69984]: https://github.com/rust-lang/rust/pull/69984/
+[69813]: https://github.com/rust-lang/rust/pull/69813/
+[69464]: https://github.com/rust-lang/rust/pull/69464/
+[68717]: https://github.com/rust-lang/rust/pull/68717/
+[`Arc::as_ptr`]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.as_ptr
+[`BTreeMap::remove_entry`]: https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html#method.remove_entry
+[`Rc::as_ptr`]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.as_ptr
+[`rc::Weak::as_ptr`]: https://doc.rust-lang.org/stable/std/rc/struct.Weak.html#method.as_ptr
+[`rc::Weak::from_raw`]: https://doc.rust-lang.org/stable/std/rc/struct.Weak.html#method.from_raw
+[`rc::Weak::into_raw`]: https://doc.rust-lang.org/stable/std/rc/struct.Weak.html#method.into_raw
+[`sync::Weak::as_ptr`]: https://doc.rust-lang.org/stable/std/sync/struct.Weak.html#method.as_ptr
+[`sync::Weak::from_raw`]: https://doc.rust-lang.org/stable/std/sync/struct.Weak.html#method.from_raw
+[`sync::Weak::into_raw`]: https://doc.rust-lang.org/stable/std/sync/struct.Weak.html#method.into_raw
+[`str::strip_prefix`]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.strip_prefix
+[`str::strip_suffix`]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.strip_suffix
+[`char::UNICODE_VERSION`]: https://doc.rust-lang.org/stable/std/char/constant.UNICODE_VERSION.html
+[`Span::resolved_at`]: https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.resolved_at
+[`Span::located_at`]: https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.located_at
+[`Span::mixed_site`]: https://doc.rust-lang.org/stable/proc_macro/struct.Span.html#method.mixed_site
+[`unix::process::CommandExt::arg0`]: https://doc.rust-lang.org/std/os/unix/process/trait.CommandExt.html#tymethod.arg0
+
+
+Version 1.44.1 (2020-06-18)
+===========================
+
+* [rustfmt accepts rustfmt_skip in cfg_attr again.][73078]
+* [Don't hash executable filenames on apple platforms, fixing backtraces.][cargo/8329]
+* [Fix crashes when finding backtrace on macOS.][71397]
+* [Clippy applies lint levels into different files.][clippy/5356]
+
+[71397]: https://github.com/rust-lang/rust/issues/71397
+[73078]: https://github.com/rust-lang/rust/issues/73078
+[cargo/8329]: https://github.com/rust-lang/cargo/pull/8329
+[clippy/5356]: https://github.com/rust-lang/rust-clippy/issues/5356
+
+
 Version 1.44.0 (2020-06-04)
 ==========================
 

config.toml.example

@@ -391,8 +391,7 @@
 # desired in distributions, for example.
 #rpath = true
 
-# Emits extraneous output from tests to ensure that failures of the test
-# harness are debuggable just from logfiles.
+# Emits extra output from tests so test failures are debuggable just from logfiles.
 #verbose-tests = false
 
 # Flag indicating whether tests are compiled with optimizations (the -O flag).

src/bootstrap/bin/rustc.rs

@@ -76,6 +76,10 @@ fn main() {
         cmd.env("RUST_BACKTRACE", "1");
     }
 
+    if let Ok(lint_flags) = env::var("RUSTC_LINT_FLAGS") {
+        cmd.args(lint_flags.split_whitespace());
+    }
+
     if target.is_some() {
         // The stage0 compiler has a special sysroot distinct from what we
         // actually downloaded, so we just always pass the `--sysroot` option,

src/bootstrap/builder.rs

@@ -1130,22 +1130,32 @@ impl<'a> Builder<'a> {
         cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
 
         if source_type == SourceType::InTree {
+            let mut lint_flags = Vec::new();
             // When extending this list, add the new lints to the RUSTFLAGS of the
             // build_bootstrap function of src/bootstrap/bootstrap.py as well as
             // some code doesn't go through this `rustc` wrapper.
-            rustflags.arg("-Wrust_2018_idioms");
-            rustflags.arg("-Wunused_lifetimes");
+            lint_flags.push("-Wrust_2018_idioms");
+            lint_flags.push("-Wunused_lifetimes");
 
             if self.config.deny_warnings {
-                rustflags.arg("-Dwarnings");
+                lint_flags.push("-Dwarnings");
             }
 
             // FIXME(#58633) hide "unused attribute" errors in incremental
             // builds of the standard library, as the underlying checks are
             // not yet properly integrated with incremental recompilation.
             if mode == Mode::Std && compiler.stage == 0 && self.config.incremental {
-                rustflags.arg("-Aunused-attributes");
+                lint_flags.push("-Aunused-attributes");
             }
+            // This does not use RUSTFLAGS due to caching issues with Cargo.
+            // Clippy is treated as an "in tree" tool, but shares the same
+            // cache as other "submodule" tools. With these options set in
+            // RUSTFLAGS, that causes *every* shared dependency to be rebuilt.
+            // By injecting this into the rustc wrapper, this circumvents
+            // Cargo's fingerprint detection. This is fine because lint flags
+            // are always ignored in dependencies. Eventually this should be
+            // fixed via better support from Cargo.
+            cargo.env("RUSTC_LINT_FLAGS", lint_flags.join(" "));
         }
 
         if let Mode::Rustc | Mode::Codegen = mode {

src/bootstrap/native.rs

@@ -347,6 +347,11 @@ fn configure_cmake(
     // LLVM and LLD builds can produce a lot of those and hit CI limits on log size.
     cfg.define("CMAKE_INSTALL_MESSAGE", "LAZY");
 
+    // Do not allow the user's value of DESTDIR to influence where
+    // LLVM will install itself. LLVM must always be installed in our
+    // own build directories.
+    cfg.env("DESTDIR", "");
+
     if builder.config.ninja {
         cfg.generator("Ninja");
     }

src/liballoc/task.rs

@@ -69,14 +69,13 @@ fn raw_waker<W: Wake + Send + Sync + 'static>(waker: Arc<W>) -> RawWaker {
 
     // Wake by value, moving the Arc into the Wake::wake function
     unsafe fn wake<W: Wake + Send + Sync + 'static>(waker: *const ()) {
-        let waker: Arc<W> = unsafe { Arc::from_raw(waker as *const W) };
+        let waker = unsafe { Arc::from_raw(waker as *const W) };
         <W as Wake>::wake(waker);
     }
 
     // Wake by reference, wrap the waker in ManuallyDrop to avoid dropping it
     unsafe fn wake_by_ref<W: Wake + Send + Sync + 'static>(waker: *const ()) {
-        let waker: ManuallyDrop<Arc<W>> =
-            unsafe { ManuallyDrop::new(Arc::from_raw(waker as *const W)) };
+        let waker = unsafe { ManuallyDrop::new(Arc::from_raw(waker as *const W)) };
         <W as Wake>::wake_by_ref(&waker);
     }
 

src/libcore/iter/range.rs

@@ -504,9 +504,6 @@ impl<A: Step> Iterator for ops::Range<A> {
     fn next(&mut self) -> Option<A> {
         if self.start < self.end {
             // SAFETY: just checked precondition
-            // We use the unchecked version here, because
-            // this helps LLVM vectorize loops for some ranges
-            // that don't get vectorized otherwise.
             let n = unsafe { Step::forward_unchecked(self.start.clone(), 1) };
             Some(mem::replace(&mut self.start, n))
         } else {
@@ -528,7 +525,8 @@ impl<A: Step> Iterator for ops::Range<A> {
     fn nth(&mut self, n: usize) -> Option<A> {
         if let Some(plus_n) = Step::forward_checked(self.start.clone(), n) {
             if plus_n < self.end {
-                self.start = Step::forward(plus_n.clone(), 1);
+                // SAFETY: just checked precondition
+                self.start = unsafe { Step::forward_unchecked(plus_n.clone(), 1) };
                 return Some(plus_n);
             }
         }
@@ -589,7 +587,8 @@ impl<A: Step> DoubleEndedIterator for ops::Range<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.start < self.end {
-            self.end = Step::backward(self.end.clone(), 1);
+            // SAFETY: just checked precondition
+            self.end = unsafe { Step::backward_unchecked(self.end.clone(), 1) };
             Some(self.end.clone())
         } else {
             None
@@ -600,7 +599,8 @@ impl<A: Step> DoubleEndedIterator for ops::Range<A> {
     fn nth_back(&mut self, n: usize) -> Option<A> {
         if let Some(minus_n) = Step::backward_checked(self.end.clone(), n) {
             if minus_n > self.start {
-                self.end = Step::backward(minus_n, 1);
+                // SAFETY: just checked precondition
+                self.end = unsafe { Step::backward_unchecked(minus_n, 1) };
                 return Some(self.end.clone());
             }
         }
@@ -657,9 +657,6 @@ impl<A: Step> Iterator for ops::RangeInclusive<A> {
         let is_iterating = self.start < self.end;
         Some(if is_iterating {
             // SAFETY: just checked precondition
-            // We use the unchecked version here, because
-            // otherwise `for _ in '\0'..=char::MAX`
-            // does not successfully remove panicking code.
             let n = unsafe { Step::forward_unchecked(self.start.clone(), 1) };
             mem::replace(&mut self.start, n)
         } else {
@@ -722,7 +719,8 @@ impl<A: Step> Iterator for ops::RangeInclusive<A> {
         let mut accum = init;
 
         while self.start < self.end {
-            let n = Step::forward(self.start.clone(), 1);
+            // SAFETY: just checked precondition
+            let n = unsafe { Step::forward_unchecked(self.start.clone(), 1) };
             let n = mem::replace(&mut self.start, n);
             accum = f(accum, n)?;
         }
@@ -775,7 +773,8 @@ impl<A: Step> DoubleEndedIterator for ops::RangeInclusive<A> {
         }
         let is_iterating = self.start < self.end;
         Some(if is_iterating {
-            let n = Step::backward(self.end.clone(), 1);
+            // SAFETY: just checked precondition
+            let n = unsafe { Step::backward_unchecked(self.end.clone(), 1) };
             mem::replace(&mut self.end, n)
         } else {
             self.exhausted = true;
@@ -825,7 +824,8 @@ impl<A: Step> DoubleEndedIterator for ops::RangeInclusive<A> {
         let mut accum = init;
 
         while self.start < self.end {
-            let n = Step::backward(self.end.clone(), 1);
+            // SAFETY: just checked precondition
+            let n = unsafe { Step::backward_unchecked(self.end.clone(), 1) };
             let n = mem::replace(&mut self.end, n);
             accum = f(accum, n)?;
         }

src/libcore/lib.rs

@@ -148,6 +148,7 @@
 #![feature(associated_type_bounds)]
 #![feature(const_type_id)]
 #![feature(const_caller_location)]
+#![feature(slice_ptr_get)]
 #![feature(no_niche)] // rust-lang/rust#68303
 #![feature(unsafe_block_in_unsafe_fn)]
 #![deny(unsafe_op_in_unsafe_fn)]