Auto merge of rust-lang#74817 - JohnTitor:rollup-0fchdye, r=JohnTitor

Rollup of 6 pull requests

Successful merges:

 - rust-lang#74088 (Avoid writes without any data in `Write::write_all_vectored`)
 - rust-lang#74598 (Fix sync_once_cell_does_not_leak_partially_constructed_boxes)
 - rust-lang#74750 (Clean up some uses of logging in ui tests)
 - rust-lang#74783 (python codes cleanup)
 - rust-lang#74790 (Don't italicize comments in ayu theme)
 - rust-lang#74799 (Fixed typo in `closure`)

Failed merges:

r? @ghost

Author: bors

src/etc/htmldocck.py

@@ -125,8 +125,8 @@
     from htmlentitydefs import name2codepoint
 
 # "void elements" (no closing tag) from the HTML Standard section 12.1.2
-VOID_ELEMENTS = set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
-                     'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
+VOID_ELEMENTS = {'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
+                     'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'}
 
 # Python 2 -> 3 compatibility
 try:
@@ -146,7 +146,7 @@ def __init__(self, target=None):
         self.__builder = target or ET.TreeBuilder()
 
     def handle_starttag(self, tag, attrs):
-        attrs = dict((k, v or '') for k, v in attrs)
+        attrs = {k: v or '' for k, v in attrs}
         self.__builder.start(tag, attrs)
         if tag in VOID_ELEMENTS:
             self.__builder.end(tag)
@@ -155,7 +155,7 @@ def handle_endtag(self, tag):
         self.__builder.end(tag)
 
     def handle_startendtag(self, tag, attrs):
-        attrs = dict((k, v or '') for k, v in attrs)
+        attrs = {k: v or '' for k, v in attrs}
         self.__builder.start(tag, attrs)
         self.__builder.end(tag)
 

src/libcore/ops/function.rs

@@ -160,7 +160,7 @@ pub trait FnMut<Args>: FnOnce<Args> {
 /// times. Because of this, if the only thing known about a type is that it
 /// implements `FnOnce`, it can only be called once.
 ///
-/// `FnOnce` is implemented automatically by closure that might consume captured
+/// `FnOnce` is implemented automatically by closures that might consume captured
 /// variables, as well as all types that implement [`FnMut`], e.g., (safe)
 /// [function pointers] (since `FnOnce` is a supertrait of [`FnMut`]).
 ///

src/librustdoc/html/static/themes/ayu.css

@@ -199,7 +199,6 @@ pre {
 
 pre.rust .comment, pre.rust .doccomment {
 	color: #788797;
-	font-style: italic;
 }
 
 nav:not(.sidebar) {

src/libstd/io/mod.rs

@@ -251,7 +251,6 @@
 
 use crate::cmp;
 use crate::fmt;
-use crate::mem;
 use crate::memchr;
 use crate::ops::{Deref, DerefMut};
 use crate::ptr;
@@ -1435,12 +1434,15 @@ pub trait Write {
     /// ```
     #[unstable(feature = "write_all_vectored", issue = "70436")]
     fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
+        // Guarantee that bufs is empty if it contains no data,
+        // to avoid calling write_vectored if there is no data to be written.
+        bufs = IoSlice::advance(bufs, 0);
         while !bufs.is_empty() {
             match self.write_vectored(bufs) {
                 Ok(0) => {
                     return Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"));
                 }
-                Ok(n) => bufs = IoSlice::advance(mem::take(&mut bufs), n),
+                Ok(n) => bufs = IoSlice::advance(bufs, n),
                 Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
                 Err(e) => return Err(e),
             }
@@ -2958,6 +2960,7 @@ mod tests {
         #[rustfmt::skip] // Becomes unreadable otherwise.
         let tests: Vec<(_, &'static [u8])> = vec![
             (vec![], &[]),
+            (vec![IoSlice::new(&[]), IoSlice::new(&[])], &[]),
             (vec![IoSlice::new(&[1])], &[1]),
             (vec![IoSlice::new(&[1, 2])], &[1, 2]),
             (vec![IoSlice::new(&[1, 2, 3])], &[1, 2, 3]),

src/libstd/lazy.rs

@@ -827,6 +827,8 @@ mod tests {
                         tx.send(msg).unwrap();
                         break;
                     }
+                    #[cfg(target_env = "sgx")]
+                    crate::thread::yield_now();
                 }
             });
         }

src/test/ui/binding/func-arg-ref-pattern.rs

@@ -1,5 +1,4 @@
 // run-pass
-// exec-env:RUST_POISON_ON_FREE=1
 
 // Test argument patterns where we create refs to the inside of
 // boxes. Make sure that we don't free the box as we match the

src/test/ui/issues/issue-18075.rs

@@ -1,5 +1,5 @@
 // run-pass
-// exec-env:RUSTC_LOG=rustc::middle=debug
+// rustc-env:RUSTC_LOG=rustc::middle=debug
 
 fn main() {
     let b = 1isize;

src/test/ui/issues/issue-34932.rs

@@ -1,6 +1,5 @@
 // run-pass
 // compile-flags:--test
-// rustc-env:RUSTC_BOOTSTRAP_KEY=
 #![cfg(any())] // This test should be configured away
 #![feature(rustc_attrs)] // Test that this is allowed on stable/beta
 #![feature(iter_arith_traits)] // Test that this is not unused

src/test/ui/logging-only-prints-once.rs

@@ -1,7 +1,6 @@
 // run-pass
 // ignore-windows
 // ignore-emscripten no threads support
-// exec-env:RUSTC_LOG=debug
 
 use std::cell::Cell;
 use std::fmt;
@@ -19,10 +18,13 @@ impl fmt::Debug for Foo {
 }
 
 pub fn main() {
-    thread::spawn(move|| {
+    thread::spawn(move || {
         let mut f = Foo(Cell::new(0));
         println!("{:?}", f);
         let Foo(ref mut f) = f;
         assert_eq!(f.get(), 1);
-    }).join().ok().unwrap();
+    })
+    .join()
+    .ok()
+    .unwrap();
 }

src/test/ui/logging_before_rt_started.rs

@@ -1,5 +1,3 @@
-// rustc-env:RUST_NEW_ERROR_FORMAT
-
 #![feature(const_fn)]
 
 trait Foo {

src/test/ui/mismatched_types/const-fn-in-trait.rs

@@ -1,11 +1,11 @@
 error[E0379]: functions in traits cannot be declared const
-  --> $DIR/const-fn-in-trait.rs:7:5
+  --> $DIR/const-fn-in-trait.rs:5:5
    |
 LL |     const fn g();
    |     ^^^^^ functions in traits cannot be const
 
 error[E0379]: functions in traits cannot be declared const
-  --> $DIR/const-fn-in-trait.rs:11:5
+  --> $DIR/const-fn-in-trait.rs:9:5
    |
 LL |     const fn f() -> u32 { 22 }
    |     ^^^^^ functions in traits cannot be const

src/test/ui/mismatched_types/const-fn-in-trait.stderr

@@ -1,5 +1,3 @@
-// rustc-env:RUST_NEW_ERROR_FORMAT
-
 trait Foo {
     fn foo(x: u16);
     fn bar(&mut self, bar: &mut Bar);

src/test/ui/mismatched_types/trait-impl-fn-incompatibility.rs

@@ -1,5 +1,5 @@
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/trait-impl-fn-incompatibility.rs:11:15
+  --> $DIR/trait-impl-fn-incompatibility.rs:9:15
    |
 LL |     fn foo(x: u16);
    |               --- type in trait
@@ -11,7 +11,7 @@ LL |     fn foo(x: i16) { }
               found fn pointer `fn(i16)`
 
 error[E0053]: method `bar` has an incompatible type for trait
-  --> $DIR/trait-impl-fn-incompatibility.rs:12:28
+  --> $DIR/trait-impl-fn-incompatibility.rs:10:28
    |
 LL |     fn bar(&mut self, bar: &mut Bar);
    |                            -------- type in trait

src/test/ui/mismatched_types/trait-impl-fn-incompatibility.stderr

@@ -2,7 +2,7 @@
 #![allow(unused_must_use)]
 #![allow(unused_mut)]
 // ignore-windows
-// exec-env:RUSTC_LOG=debug
+// exec-env:RUST_LOG=debug
 // ignore-emscripten no threads support
 
 // regression test for issue #10405, make sure we don't call println! too soon.
@@ -11,5 +11,5 @@ use std::thread::Builder;
 
 pub fn main() {
     let mut t = Builder::new();
-    t.spawn(move|| ());
+    t.spawn(move || ());
 }

src/test/ui/threads-sendsync/spawning-with-debug.rs

@@ -623,7 +623,7 @@ impl<'test> TestCx<'test> {
             .arg("-L")
             .arg(&aux_dir)
             .args(&self.props.compile_flags)
-            .envs(self.props.exec_env.clone());
+            .envs(self.props.rustc_env.clone());
         self.maybe_add_external_args(
             &mut rustc,
             self.split_maybe_args(&self.config.target_rustcflags),