Auto merge of #67828 - JohnTitor:rollup-qmswkkl, r=JohnTitor

Rollup of 10 pull requests

Successful merges:

 - #67450 (Allow for setting a ThinLTO import limit during bootstrap)
 - #67595 (Suggest adding a lifetime constraint for opaque type)
 - #67636 (allow rustfmt key in [build] section)
 - #67736 (Less-than is asymmetric, not antisymmetric)
 - #67762 (Add missing links for insecure_time)
 - #67783 (Warn for bindings named same as variants when matching against a borrow)
 - #67796 (Ensure that we process projections during MIR inlining)
 - #67807 (Use drop instead of the toilet closure `|_| ()`)
 - #67816 (Clean up err codes)
 - #67825 (Minor: change take() docs grammar to match other docs)

Failed merges:

r? @ghost

Author: bors

config.toml.example

@@ -138,6 +138,10 @@
 # specified, use this rustc binary instead as the stage0 snapshot compiler.
 #rustc = "/path/to/bin/rustc"
 
+# Instead of download the src/stage0.txt version of rustfmt specified,
+# use this rustfmt binary instead as the stage0 snapshot rustfmt.
+#rustfmt = "/path/to/bin/rustfmt"
+
 # Flag to specify whether any documentation is built. If false, rustdoc and
 # friends will still be compiled but they will not be used to generate any
 # documentation.
@@ -406,6 +410,13 @@
 # Whether to verify generated LLVM IR
 #verify-llvm-ir = false
 
+# Compile the compiler with a non-default ThinLTO import limit. This import
+# limit controls the maximum size of functions imported by ThinLTO. Decreasing
+# will make code compile faster at the expense of lower runtime performance.
+# If `incremental` is set to true above, the import limit will default to 10
+# instead of LLVM's default of 100.
+#thin-lto-import-instr-limit = 100
+
 # Map all debuginfo paths for libstd and crates to `/rust/$sha/$crate/...`,
 # generally only set for releases
 #remap-debuginfo = false

src/bootstrap/builder.rs

@@ -1183,6 +1183,21 @@ impl<'a> Builder<'a> {
             rustflags.arg("-Cprefer-dynamic");
         }
 
+        // When building incrementally we default to a lower ThinLTO import limit
+        // (unless explicitly specified otherwise). This will produce a somewhat
+        // slower code but give way better compile times.
+        {
+            let limit = match self.config.rust_thin_lto_import_instr_limit {
+                Some(limit) => Some(limit),
+                None if self.config.incremental => Some(10),
+                _ => None,
+            };
+
+            if let Some(limit) = limit {
+                rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={}", limit));
+            }
+        }
+
         Cargo { command: cargo, rustflags }
     }
 

src/bootstrap/config.rs

@@ -108,6 +108,7 @@ pub struct Config {
     pub rust_dist_src: bool,
     pub rust_codegen_backends: Vec<Interned<String>>,
     pub rust_verify_llvm_ir: bool,
+    pub rust_thin_lto_import_instr_limit: Option<u32>,
     pub rust_remap_debuginfo: bool,
 
     pub build: Interned<String>,
@@ -202,6 +203,7 @@ struct Build {
     target: Vec<String>,
     cargo: Option<String>,
     rustc: Option<String>,
+    rustfmt: Option<String>, /* allow bootstrap.py to use rustfmt key */
     docs: Option<bool>,
     compiler_docs: Option<bool>,
     submodules: Option<bool>,
@@ -325,6 +327,7 @@ struct Rust {
     deny_warnings: Option<bool>,
     backtrace_on_ice: Option<bool>,
     verify_llvm_ir: Option<bool>,
+    thin_lto_import_instr_limit: Option<u32>,
     remap_debuginfo: Option<bool>,
     jemalloc: Option<bool>,
     test_compare_mode: Option<bool>,
@@ -569,6 +572,7 @@ impl Config {
             set(&mut config.deny_warnings, flags.deny_warnings.or(rust.deny_warnings));
             set(&mut config.backtrace_on_ice, rust.backtrace_on_ice);
             set(&mut config.rust_verify_llvm_ir, rust.verify_llvm_ir);
+            config.rust_thin_lto_import_instr_limit = rust.thin_lto_import_instr_limit;
             set(&mut config.rust_remap_debuginfo, rust.remap_debuginfo);
 
             if let Some(ref backends) = rust.codegen_backends {

src/ci/docker/x86_64-gnu-llvm-7/Dockerfile

@@ -25,7 +25,9 @@ RUN sh /scripts/sccache.sh
 ENV RUST_CONFIGURE_ARGS \
       --build=x86_64-unknown-linux-gnu \
       --llvm-root=/usr/lib/llvm-7 \
-      --enable-llvm-link-shared
+      --enable-llvm-link-shared \
+      --set rust.thin-lto-import-instr-limit=10
+
 ENV SCRIPT python2.7 ../x.py test src/tools/tidy && python2.7 ../x.py test
 
 # The purpose of this container isn't to test with debug assertions and

src/liballoc/tests/arc.rs

@@ -142,7 +142,7 @@ fn shared_from_iter_trustedlen_normal() {
 
     // Try a ZST to make sure it is handled well.
     {
-        let iter = (0..SHARED_ITER_MAX).map(|_| ());
+        let iter = (0..SHARED_ITER_MAX).map(drop);
         let vec = iter.clone().collect::<Vec<_>>();
         let rc = iter.collect::<Rc<[_]>>();
         assert_eq!(&*vec, &*rc);

src/liballoc/tests/rc.rs

@@ -138,7 +138,7 @@ fn shared_from_iter_trustedlen_normal() {
 
     // Try a ZST to make sure it is handled well.
     {
-        let iter = (0..SHARED_ITER_MAX).map(|_| ());
+        let iter = (0..SHARED_ITER_MAX).map(drop);
         let vec = iter.clone().collect::<Vec<_>>();
         let rc = iter.collect::<Rc<[_]>>();
         assert_eq!(&*vec, &*rc);

src/libcore/cmp.rs

@@ -495,7 +495,7 @@ impl<T: Ord> Ord for Reverse<T> {
 ///
 /// An order is a total order if it is (for all `a`, `b` and `c`):
 ///
-/// - total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true; and
+/// - total and asymmetric: exactly one of `a < b`, `a == b` or `a > b` is true; and
 /// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
 ///
 /// ## Derivable
@@ -674,7 +674,7 @@ impl PartialOrd for Ordering {
 ///
 /// The comparison must satisfy, for all `a`, `b` and `c`:
 ///
-/// - antisymmetry: if `a < b` then `!(a > b)`, as well as `a > b` implying `!(a < b)`; and
+/// - asymmetry: if `a < b` then `!(a > b)`, as well as `a > b` implying `!(a < b)`; and
 /// - transitivity: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
 ///
 /// Note that these requirements mean that the trait itself must be implemented symmetrically and

src/libcore/mem/mod.rs

@@ -557,7 +557,7 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
     }
 }
 
-/// Replace `dest` with the default value of `T`, and return the previous `dest` value.
+/// Replaces `dest` with the default value of `T`, returning the previous `dest` value.
 ///
 /// # Examples
 ///

src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -54,7 +54,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                             err.span_suggestion(
                                 fn_return_span,
                                 &format!(
-                                    "you can add a constraint to the return type to make it last \
+                                    "you can add a bound to the return type to make it last \
                                  less than `'static` and match {}",
                                     lifetime,
                                 ),

src/librustc_error_codes/error_codes/E0130.md

@@ -1,4 +1,4 @@
-You declared a pattern as an argument in a foreign function declaration.
+A pattern was declared as an argument in a foreign function declaration.
 
 Erroneous code example:
 
@@ -9,7 +9,7 @@ extern {
 }
 ```
 
-Please replace the pattern argument with a regular one. Example:
+To fix this error, replace the pattern argument with a regular one. Example:
 
 ```
 struct SomeStruct {