Merge from rustc

core/src/char/mod.rs

@@ -24,18 +24,23 @@ mod convert;
 mod decode;
 mod methods;
 
+// stable re-exports
+#[rustfmt::skip]
 #[stable(feature = "try_from", since = "1.34.0")]
 pub use self::convert::CharTryFromError;
 #[stable(feature = "char_from_str", since = "1.20.0")]
 pub use self::convert::ParseCharError;
 #[stable(feature = "decode_utf16", since = "1.9.0")]
 pub use self::decode::{DecodeUtf16, DecodeUtf16Error};
 
+// perma-unstable re-exports
+#[rustfmt::skip]
 #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
 pub use self::methods::encode_utf16_raw; // perma-unstable
 #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
 pub use self::methods::encode_utf8_raw; // perma-unstable
 
+#[rustfmt::skip]
 use crate::ascii;
 use crate::error::Error;
 use crate::escape;

core/src/ffi/c_str.rs

@@ -94,7 +94,7 @@ use crate::str;
 /// ```
 ///
 /// [str]: prim@str "str"
-#[derive(Hash)]
+#[derive(PartialEq, Eq, Hash)]
 #[stable(feature = "core_c_str", since = "1.64.0")]
 #[rustc_has_incoherent_inherent_impls]
 #[lang = "CStr"]
@@ -104,7 +104,6 @@ use crate::str;
 // want `repr(transparent)` but we don't want it to show up in rustdoc, so we hide it under
 // `cfg(doc)`. This is an ad-hoc implementation of attribute privacy.
 #[repr(transparent)]
-#[allow(clippy::derived_hash_with_manual_eq)]
 pub struct CStr {
     // FIXME: this should not be represented with a DST slice but rather with
     //        just a raw `c_char` along with some form of marker to make
@@ -678,15 +677,9 @@ impl CStr {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for CStr {
-    #[inline]
-    fn eq(&self, other: &CStr) -> bool {
-        self.to_bytes().eq(other.to_bytes())
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Eq for CStr {}
+// `.to_bytes()` representations are compared instead of the inner `[c_char]`s,
+// because `c_char` is `i8` (not `u8`) on some platforms.
+// That is why this is implemented manually and not derived.
 #[stable(feature = "rust1", since = "1.0.0")]
 impl PartialOrd for CStr {
     #[inline]

core/src/intrinsics/simd.rs

@@ -243,18 +243,6 @@ extern "rust-intrinsic" {
     #[rustc_nounwind]
     pub fn simd_shuffle<T, U, V>(x: T, y: T, idx: U) -> V;
 
-    /// Shuffle two vectors by const indices.
-    ///
-    /// `T` must be a vector.
-    ///
-    /// `U` must be a vector with the same element type as `T` and the same length as `IDX`.
-    ///
-    /// Returns a new vector such that element `i` is selected from `xy[IDX[i]]`, where `xy`
-    /// is the concatenation of `x` and `y`. It is a compile-time error if `IDX[i]` is out-of-bounds
-    /// of `xy`.
-    #[rustc_nounwind]
-    pub fn simd_shuffle_generic<T, U, const IDX: &'static [u32]>(x: T, y: T) -> U;
-
     /// Read a vector of pointers.
     ///
     /// `T` must be a vector.

core/src/lib.rs

@@ -249,7 +249,6 @@
 #![feature(transparent_unions)]
 #![feature(try_blocks)]
 #![feature(unboxed_closures)]
-#![feature(unsized_const_params)]
 #![feature(unsized_fn_params)]
 #![feature(with_negative_coherence)]
 // tidy-alphabetical-end

core/src/marker.rs

@@ -42,6 +42,8 @@ use crate::hash::Hasher;
 /// }
 /// ```
 #[unstable(feature = "internal_impls_macro", issue = "none")]
+// Allow implementations of `UnsizedConstParamTy` even though std cannot use that feature.
+#[allow_internal_unstable(unsized_const_params)]
 macro marker_impls {
     ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(, $($rest:tt)*)? ) => {
         $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for $T {}

core/src/unicode/mod.rs

@@ -1,13 +1,15 @@
 #![unstable(feature = "unicode_internals", issue = "none")]
 #![allow(missing_docs)]
 
-// The `pub use` ones are for use in alloc, and are not re-exported in std.
-
-pub(crate) use unicode_data::alphabetic::lookup as Alphabetic;
+// for use in alloc, not re-exported in std.
+#[rustfmt::skip]
 pub use unicode_data::case_ignorable::lookup as Case_Ignorable;
 pub use unicode_data::cased::lookup as Cased;
-pub(crate) use unicode_data::cc::lookup as Cc;
 pub use unicode_data::conversions;
+
+#[rustfmt::skip]
+pub(crate) use unicode_data::alphabetic::lookup as Alphabetic;
+pub(crate) use unicode_data::cc::lookup as Cc;
 pub(crate) use unicode_data::grapheme_extend::lookup as Grapheme_Extend;
 pub(crate) use unicode_data::lowercase::lookup as Lowercase;
 pub(crate) use unicode_data::n::lookup as N;

core/tests/ffi.rs

@@ -0,0 +1 @@
+mod cstr;

core/tests/ffi/cstr.rs

@@ -0,0 +1,15 @@
+use core::ffi::CStr;
+
+#[test]
+fn compares_as_u8s() {
+    let a: &CStr = c"Hello!"; // Starts with ascii
+    let a_bytes: &[u8] = a.to_bytes();
+    assert!((..0b1000_0000).contains(&a_bytes[0]));
+
+    let b: &CStr = c"こんにちは！"; // Starts with non ascii
+    let b_bytes: &[u8] = b.to_bytes();
+    assert!((0b1000_0000..).contains(&b_bytes[0]));
+
+    assert_eq!(Ord::cmp(a, b), Ord::cmp(a_bytes, b_bytes));
+    assert_eq!(PartialOrd::partial_cmp(a, b), PartialOrd::partial_cmp(a_bytes, b_bytes));
+}

core/tests/lib.rs

@@ -132,6 +132,7 @@ mod clone;
 mod cmp;
 mod const_ptr;
 mod convert;
+mod ffi;
 mod fmt;
 mod future;
 mod hash;

std/src/rt.rs

@@ -16,9 +16,11 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(unused_macros)]
 
+#[rustfmt::skip]
 pub use crate::panicking::{begin_panic, panic_count};
 pub use core::panicking::{panic_display, panic_fmt};
 
+#[rustfmt::skip]
 use crate::sync::Once;
 use crate::sys;
 use crate::thread::{self, Thread};

std/src/sys/pal/unix/net.rs

@@ -214,16 +214,25 @@ impl Socket {
                 }
                 0 => {}
                 _ => {
-                    // linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look
-                    // for POLLHUP rather than read readiness
-                    if pollfd.revents & libc::POLLHUP != 0 {
-                        let e = self.take_error()?.unwrap_or_else(|| {
-                            io::const_io_error!(
-                                io::ErrorKind::Uncategorized,
-                                "no error set after POLLHUP",
-                            )
-                        });
-                        return Err(e);
+                    if cfg!(target_os = "vxworks") {
+                        // VxWorks poll does not return  POLLHUP or POLLERR in revents. Check if the
+                        // connnection actually succeeded and return ok only when the socket is
+                        // ready and no errors were found.
+                        if let Some(e) = self.take_error()? {
+                            return Err(e);
+                        }
+                    } else {
+                        // linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look
+                        // for POLLHUP or POLLERR rather than read readiness
+                        if pollfd.revents & (libc::POLLHUP | libc::POLLERR) != 0 {
+                            let e = self.take_error()?.unwrap_or_else(|| {
+                                io::const_io_error!(
+                                    io::ErrorKind::Uncategorized,
+                                    "no error set after POLLHUP",
+                                )
+                            });
+                            return Err(e);
+                        }
                     }
 
                     return Ok(());

std/src/sys/pal/windows/fs.rs

@@ -416,8 +416,8 @@ impl File {
                     dwHighDateTime: (info.LastWriteTime >> 32) as u32,
                 },
                 change_time: Some(c::FILETIME {
-                    dhLowDateTime: info.ChangeTime as c::DWORD,
-                    dhHighDateTime: (info.ChangeTime >> 32) as c::DWORD,
+                    dwLowDateTime: info.ChangeTime as u32,
+                    dwHighDateTime: (info.ChangeTime >> 32) as u32,
                 }),
                 file_size: 0,
                 reparse_tag: 0,