Rollup of 10 pull requests #151965

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed

JonathanBrouwer wants to merge 23 commits into rust-lang:main from JonathanBrouwer:rollup-mn7HX4P

compiler/rustc_ast/src/tokenstream.rs

-Original file line number
+Diff line change
@@ Expand Up / @@ -354,7 +354,13 @@ fn make_attr_token_stream( @@
                             FrameData { open_delim_sp: Some((delim, span, spacing)), inner: vec![] },
                         ));
                     } else if let Some(delim) = kind.close_delim() {
-                        let frame_data = mem::replace(&mut stack_top, stack_rest.pop().unwrap());
+                        // If there's no matching opening delimiter, the token stream is malformed,
+                        // likely due to a improper delimiter positions in the source code.
+                        // It's not delimiter mismatch, and lexer can not detect it, so we just ignore it here.
+                        let Some(frame) = stack_rest.pop() else {
+                            return AttrTokenStream::new(stack_top.inner);
+                        };
+                        let frame_data = mem::replace(&mut stack_top, frame);
                         let (open_delim, open_sp, open_spacing) = frame_data.open_delim_sp.unwrap();
                         assert!(
                             open_delim.eq_ignoring_invisible_origin(&delim),
@@ Expand Down @@

compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -243,24 +243,24 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
  
            .flat_map(|super_poly_trait_ref| {

                tcx.associated_items(super_poly_trait_ref.def_id())

                    .in_definition_order()

                    .filter(|item| item.is_type())

                    .filter(|item| item.is_type() || item.is_const())

                    .filter(|item| !tcx.generics_require_sized_self(item.def_id))

                    .map(move |assoc_ty| {

                    .map(move |assoc_item| {

                        super_poly_trait_ref.map_bound(|super_trait_ref| {

                            let alias_ty =

                                ty::AliasTy::new_from_args(tcx, assoc_ty.def_id, super_trait_ref.args);

                            let resolved = tcx.normalize_erasing_regions(

                            let projection_term = ty::AliasTerm::new_from_args(

                                tcx,

                                assoc_item.def_id,

                                super_trait_ref.args,

                            );

                            let term = tcx.normalize_erasing_regions(

                                ty::TypingEnv::fully_monomorphized(),

                                alias_ty.to_ty(tcx),

                                projection_term.to_term(tcx),

                            );

                            debug!("Resolved {:?} -> {resolved}", alias_ty.to_ty(tcx));

                            debug!("Projection {:?} -> {term}", projection_term.to_term(tcx),);

                            ty::ExistentialPredicate::Projection(

                                ty::ExistentialProjection::erase_self_ty(

                                    tcx,

                                    ty::ProjectionPredicate {

                                        projection_term: alias_ty.into(),

                                        term: resolved.into(),

                                    },

                                    ty::ProjectionPredicate { projection_term, term },

                                ),

                            )

                        })

compiler/rustc_target/src/spec/targets/hexagon_unknown_linux_musl.rs

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -1,4 +1,4 @@
  
    use crate::spec::{Arch, Cc, LinkerFlavor, Target, TargetMetadata, base};

    use crate::spec::{Arch, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base};

    pub(crate) fn target() -> Target {

        let mut base = base::linux_musl::opts();

    @@ -8,8 +8,8 @@ pub(crate) fn target() -> Target {
  
        base.features = "-small-data,+hvx-length128b".into();

        base.has_rpath = true;

        base.linker = Some("rust-lld".into());

        base.linker_flavor = LinkerFlavor::Unix(Cc::Yes);

        base.linker = Some("hexagon-unknown-linux-musl-clang".into());

        base.linker_flavor = LinkerFlavor::Gnu(Cc::Yes, Lld::No);

        base.c_enum_min_bits = Some(8);

compiler/rustc_target/src/spec/targets/hexagon_unknown_none_elf.rs

-Original file line number
+Diff line change
@@ -1,4 +1,6 @@
-    use crate::spec::{Arch, PanicStrategy, Target, TargetMetadata, TargetOptions};
+    use crate::spec::{
+        Arch, Cc, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, TargetOptions,
+    };
     pub(crate) fn target() -> Target {
         Target {
@@ Expand Down Expand Up / @@ -28,6 +30,7 @@ pub(crate) fn target() -> Target { @@
                 emit_debug_gdb_scripts: false,
                 c_enum_min_bits: Some(8),
                 linker: Some("rust-lld".into()),
+                linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
                 ..Default::default()
             },
         }
@@ Expand Down @@

compiler/rustc_target/src/spec/targets/hexagon_unknown_qurt.rs

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -24,8 +24,8 @@ pub(crate) fn target() -> Target {
  
                os: Os::Qurt,

                vendor: "unknown".into(),

                cpu: "hexagonv69".into(),

                linker: Some("rust-lld".into()),

                linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),

                linker: Some("hexagon-clang".into()),

                linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No),

                exe_suffix: ".elf".into(),

                dynamic_linking: true,

                executables: true,

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

-Original file line number
+Diff line change
@@ Expand Up / @@ -1607,6 +1607,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { @@
                             };
                         if let Some(lhs) = lhs.to_alias_term()
+                            && let ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst = lhs.kind(self.tcx)
                             && let Some((better_type_err, expected_term)) =
                                 derive_better_type_error(lhs, rhs)
                         {
@@ Expand All / @@ -1615,6 +1616,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { @@
                                 better_type_err,
                             )
                         } else if let Some(rhs) = rhs.to_alias_term()
+                            && let ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst = rhs.kind(self.tcx)
                             && let Some((better_type_err, expected_term)) =
                                 derive_better_type_error(rhs, lhs)
                         {
@@ Expand Down @@

library/core/src/convert/num.rs

-Original file line number
+Diff line change
@@ Expand Up @@
     impl_float_to_int!(f64 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
     impl_float_to_int!(f128 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
-    // Conversion traits for primitive integer and float types
-    // Conversions T -> T are covered by a blanket impl and therefore excluded
-    // Some conversions from and to usize/isize are not implemented due to portability concerns
+    /// Implement `From<bool>` for integers
+    macro_rules! impl_from_bool {
+        ($($int:ty)*) => {$(
+            #[stable(feature = "from_bool", since = "1.28.0")]
+            #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+            impl const From<bool> for $int {
+                /// Converts from [`bool`] to
+                #[doc = concat!("[`", stringify!($int), "`]")]
+                /// , by turning `false` into `0` and `true` into `1`.
+                ///
+                /// # Examples
+                ///
+                /// ```
+                #[doc = concat!("assert_eq!(", stringify!($int), "::from(false), 0);")]
+                ///
+                #[doc = concat!("assert_eq!(", stringify!($int), "::from(true), 1);")]
+                /// ```
+                #[inline(always)]
+                fn from(b: bool) -> Self {
+                    b as Self
+                }
+            }
+        )*}
+    }
+    // boolean -> integer
+    impl_from_bool!(u8 u16 u32 u64 u128 usize);
+    impl_from_bool!(i8 i16 i32 i64 i128 isize);
+    /// Implement `From<$small>` for `$large`
     macro_rules! impl_from {
-        (bool => $Int:ty $(,)?) => {
-            impl_from!(
-                bool => $Int,
-                #[stable(feature = "from_bool", since = "1.28.0")],
-                concat!(
-                    "Converts a [`bool`] to [`", stringify!($Int), "`] losslessly.\n",
-                    "The resulting value is `0` for `false` and `1` for `true` values.\n",
-                    "\n",
-                    "# Examples\n",
-                    "\n",
-                    "```\n",
-                    "assert_eq!(", stringify!($Int), "::from(true), 1);\n",
-                    "assert_eq!(", stringify!($Int), "::from(false), 0);\n",
-                    "```\n",
-                ),
-            );
-        };
-        ($Small:ty => $Large:ty, #[$attr:meta] $(,)?) => {
-            impl_from!(
-                $Small => $Large,
-                #[$attr],
-                concat!("Converts [`", stringify!($Small), "`] to [`", stringify!($Large), "`] losslessly."),
-            );
-        };
-        ($Small:ty => $Large:ty, #[$attr:meta], $doc:expr $(,)?) => {
+        ($small:ty => $large:ty, #[$attr:meta]) => {
             #[$attr]
             #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-            impl const From<$Small> for $Large {
-                // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
-                // Rustdocs on functions do not.
-                #[doc = $doc]
+            impl const From<$small> for $large {
+                #[doc = concat!("Converts from [`", stringify!($small), "`] to [`", stringify!($large), "`] losslessly.")]
                 #[inline(always)]
-                fn from(small: $Small) -> Self {
+                fn from(small: $small) -> Self {
+                    debug_assert!(<$large>::MIN as i128 <= <$small>::MIN as i128);
+                    debug_assert!(<$small>::MAX as u128 <= <$large>::MAX as u128);
                     small as Self
                 }
             }
-        };
+        }
     }
-    // boolean -> integer
-    impl_from!(bool => u8);
-    impl_from!(bool => u16);
-    impl_from!(bool => u32);
-    impl_from!(bool => u64);
-    impl_from!(bool => u128);
-    impl_from!(bool => usize);
-    impl_from!(bool => i8);
-    impl_from!(bool => i16);
-    impl_from!(bool => i32);
-    impl_from!(bool => i64);
-    impl_from!(bool => i128);
-    impl_from!(bool => isize);
     // unsigned integer -> unsigned integer
     impl_from!(u8 => u16, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
     impl_from!(u8 => u32, #[stable(feature = "lossless_int_conv", since = "1.5.0")]);
@@ Expand Down Expand Up / @@ -338,12 +327,48 @@ macro_rules! impl_try_from_both_bounded { @@
         )*}
     }
+    /// Implement `TryFrom<integer>` for `bool`
+    macro_rules! impl_try_from_integer_for_bool {
+        ($($int:ty)+) => {$(
+            #[stable(feature = "try_from", since = "1.34.0")]
+            #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+            impl const TryFrom<$int> for bool {
+                type Error = TryFromIntError;
+                /// Tries to create a bool from an integer type.
+                /// Returns an error if the integer is not 0 or 1.
+                ///
+                /// # Examples
+                ///
+                /// ```
+                #[doc = concat!("assert_eq!(0_", stringify!($int), ".try_into(), Ok(false));")]
+                ///
+                #[doc = concat!("assert_eq!(1_", stringify!($int), ".try_into(), Ok(true));")]
+                ///
+                #[doc = concat!("assert!(<", stringify!($int), " as TryInto<bool>>::try_into(2).is_err());")]
+                /// ```
+                #[inline]
+                fn try_from(i: $int) -> Result<Self, Self::Error> {
+                    match i {
+=> Ok(false),
+=> Ok(true),
+                        _ => Err(TryFromIntError(())),
+                    }
+                }
+            }
+        )*}
+    }
     macro_rules! rev {
         ($mac:ident, $source:ty => $($target:ty),+) => {$(
             $mac!($target => $source);
         )*}
     }
+    // integer -> bool
+    impl_try_from_integer_for_bool!(u128 u64 u32 u16 u8);
+    impl_try_from_integer_for_bool!(i128 i64 i32 i16 i8);
     // unsigned integer -> unsigned integer
     impl_try_from_upper_bounded!(u16 => u8);
     impl_try_from_upper_bounded!(u32 => u8, u16);
@@ Expand Down @@

library/std/src/env.rs

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -518,8 +518,8 @@ pub struct JoinPathsError {
  
    ///

    /// Returns an [`Err`] (containing an error message) if one of the input

    /// [`Path`]s contains an invalid character for constructing the `PATH`

    /// variable (a double quote on Windows or a colon on Unix), or if the system

    /// does not have a `PATH`-like variable (e.g. UEFI or WASI).

    /// variable (a double quote on Windows or a colon on Unix or semicolon on

    /// UEFI), or if the system does not have a `PATH`-like variable (e.g. WASI).

    ///

    /// # Examples

    ///

library/std/src/os/windows/mod.rs

-Original file line number
+Diff line change
@@ Expand Up / @@ -29,6 +29,8 @@ @@
     pub mod ffi;
     pub mod fs;
     pub mod io;
+    #[unstable(feature = "windows_unix_domain_sockets", issue = "150487")]
+    pub mod net;
     pub mod process;
     pub mod raw;
     pub mod thread;
@@ Expand Down @@

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Rollup of 10 pull requests #151965

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!