Rollup of 5 pull requests

compiler/rustc_lint/messages.ftl

@@ -813,7 +813,7 @@ lint_unexpected_cfg_doc_cargo = see <https://doc.rust-lang.org/nightly/rustc/che
 lint_unexpected_cfg_doc_rustc = see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 lint_unexpected_cfg_from_external_macro_origin = using a cfg inside a {$macro_kind} will use the cfgs from the destination crate and not the ones from the defining crate
-lint_unexpected_cfg_from_external_macro_refer = try refering to `{$macro_name}` crate for guidance on how handle this unexpected cfg
+lint_unexpected_cfg_from_external_macro_refer = try referring to `{$macro_name}` crate for guidance on how handle this unexpected cfg
 lint_unexpected_cfg_name = unexpected `cfg` condition name: `{$name}`
 lint_unexpected_cfg_name_expected_names = expected names are: {$possibilities}{$and_more ->
         [0] {""}

compiler/rustc_lint/src/lints.rs

@@ -1816,14 +1816,14 @@ pub(crate) enum AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
 }
 
 #[derive(LintDiagnostic)]
-pub(crate) enum UnpredictableFunctionPointerComparisons<'a> {
+pub(crate) enum UnpredictableFunctionPointerComparisons<'a, 'tcx> {
     #[diag(lint_unpredictable_fn_pointer_comparisons)]
     #[note(lint_note_duplicated_fn)]
     #[note(lint_note_deduplicated_fn)]
     #[note(lint_note_visit_fn_addr_eq)]
     Suggestion {
         #[subdiagnostic]
-        sugg: UnpredictableFunctionPointerComparisonsSuggestion<'a>,
+        sugg: UnpredictableFunctionPointerComparisonsSuggestion<'a, 'tcx>,
     },
     #[diag(lint_unpredictable_fn_pointer_comparisons)]
     #[note(lint_note_duplicated_fn)]
@@ -1833,22 +1833,40 @@ pub(crate) enum UnpredictableFunctionPointerComparisons<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    lint_fn_addr_eq_suggestion,
-    style = "verbose",
-    applicability = "maybe-incorrect"
-)]
-pub(crate) struct UnpredictableFunctionPointerComparisonsSuggestion<'a> {
-    pub ne: &'a str,
-    pub cast_right: String,
-    pub deref_left: &'a str,
-    pub deref_right: &'a str,
-    #[suggestion_part(code = "{ne}std::ptr::fn_addr_eq({deref_left}")]
-    pub left: Span,
-    #[suggestion_part(code = ", {deref_right}")]
-    pub middle: Span,
-    #[suggestion_part(code = "{cast_right})")]
-    pub right: Span,
+pub(crate) enum UnpredictableFunctionPointerComparisonsSuggestion<'a, 'tcx> {
+    #[multipart_suggestion(
+        lint_fn_addr_eq_suggestion,
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
+    FnAddrEq {
+        ne: &'a str,
+        deref_left: &'a str,
+        deref_right: &'a str,
+        #[suggestion_part(code = "{ne}std::ptr::fn_addr_eq({deref_left}")]
+        left: Span,
+        #[suggestion_part(code = ", {deref_right}")]
+        middle: Span,
+        #[suggestion_part(code = ")")]
+        right: Span,
+    },
+    #[multipart_suggestion(
+        lint_fn_addr_eq_suggestion,
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
+    FnAddrEqWithCast {
+        ne: &'a str,
+        deref_left: &'a str,
+        deref_right: &'a str,
+        fn_sig: rustc_middle::ty::PolyFnSig<'tcx>,
+        #[suggestion_part(code = "{ne}std::ptr::fn_addr_eq({deref_left}")]
+        left: Span,
+        #[suggestion_part(code = ", {deref_right}")]
+        middle: Span,
+        #[suggestion_part(code = " as {fn_sig})")]
+        right: Span,
+    },
 }
 
 pub(crate) struct ImproperCTypes<'a> {

compiler/rustc_lint/src/types.rs

@@ -483,29 +483,36 @@ fn lint_fn_pointer<'tcx>(
     let middle = l_span.shrink_to_hi().until(r_span.shrink_to_lo());
     let right = r_span.shrink_to_hi().until(e.span.shrink_to_hi());
 
-    // We only check for a right cast as `FnDef` == `FnPtr` is not possible,
-    // only `FnPtr == FnDef` is possible.
-    let cast_right = if !r_ty.is_fn_ptr() {
-        let fn_sig = r_ty.fn_sig(cx.tcx);
-        format!(" as {fn_sig}")
-    } else {
-        String::new()
-    };
+    let sugg =
+        // We only check for a right cast as `FnDef` == `FnPtr` is not possible,
+        // only `FnPtr == FnDef` is possible.
+        if !r_ty.is_fn_ptr() {
+            let fn_sig = r_ty.fn_sig(cx.tcx);
 
-    cx.emit_span_lint(
-        UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS,
-        e.span,
-        UnpredictableFunctionPointerComparisons::Suggestion {
-            sugg: UnpredictableFunctionPointerComparisonsSuggestion {
+            UnpredictableFunctionPointerComparisonsSuggestion::FnAddrEqWithCast {
                 ne,
+                fn_sig,
                 deref_left,
                 deref_right,
                 left,
                 middle,
                 right,
-                cast_right,
-            },
-        },
+            }
+        } else {
+            UnpredictableFunctionPointerComparisonsSuggestion::FnAddrEq {
+                ne,
+                deref_left,
+                deref_right,
+                left,
+                middle,
+                right,
+            }
+        };
+
+    cx.emit_span_lint(
+        UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS,
+        e.span,
+        UnpredictableFunctionPointerComparisons::Suggestion { sugg },
     );
 }
 

compiler/rustc_lint/src/unqualified_local_imports.rs

@@ -31,7 +31,7 @@ declare_lint! {
     ///
     /// This lint is meant to be used with the (unstable) rustfmt setting `group_imports = "StdExternalCrate"`.
     /// That setting makes rustfmt group `self::`, `super::`, and `crate::` imports separately from those
-    /// refering to other crates. However, rustfmt cannot know whether `use c::S;` refers to a local module `c`
+    /// referring to other crates. However, rustfmt cannot know whether `use c::S;` refers to a local module `c`
     /// or an external crate `c`, so it always gets categorized as an import from another crate.
     /// To ensure consistent grouping of imports from the local crate, all local imports must
     /// start with `self::`, `super::`, or `crate::`. This lint can be used to enforce that style.

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -367,14 +367,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             .collect()
                     }
                     AdtExprBase::DefaultFields(field_types) => {
-                        itertools::zip_eq(field_names, &**field_types)
-                            .map(|(n, ty)| match fields_map.get(&n) {
+                        itertools::zip_eq(field_names, field_types)
+                            .map(|(n, &ty)| match fields_map.get(&n) {
                                 Some(v) => v.clone(),
                                 None => match variant.fields[n].value {
                                     Some(def) => {
-                                        let value = Const::from_unevaluated(this.tcx, def)
-                                            .instantiate(this.tcx, args);
-                                        this.literal_operand(expr_span, value)
+                                        let value = Const::Unevaluated(
+                                            UnevaluatedConst::new(def, args),
+                                            ty,
+                                        );
+                                        Operand::Constant(Box::new(ConstOperand {
+                                            span: expr_span,
+                                            user_ty: None,
+                                            const_: value,
+                                        }))
                                     }
                                     None => {
                                         let name = variant.fields[n].name;

tests/crashes/130797.rs

@@ -0,0 +1,23 @@
+//@ known-bug: #130797
+
+trait Transform {
+    type Output<'a>;
+}
+trait Propagate<O> {}
+trait AddChild<C> {
+    fn add_child(&self) {}
+}
+
+pub struct Node<T>(T);
+impl<T> AddChild<Box<dyn for<'b> Propagate<T::Output<'b>>>> for Node<T> where T: Transform {}
+
+fn make_graph_root() {
+    Node(Dummy).add_child()
+}
+
+struct Dummy;
+impl Transform for Dummy {
+    type Output<'a> = ();
+}
+
+pub fn main() {}

tests/crashes/132103.rs

@@ -0,0 +1,21 @@
+//@ known-bug: #132103
+//@compile-flags: -Zvalidate-mir --edition=2018 -Zinline-mir=yes
+use core::future::{async_drop_in_place, Future};
+use core::mem::{self};
+use core::pin::pin;
+use core::task::{Context, Waker};
+
+async fn test_async_drop<T>(x: T) {
+    let mut x = mem::MaybeUninit::new(x);
+    pin!(unsafe { async_drop_in_place(x.as_mut_ptr()) });
+}
+
+fn main() {
+    let waker = Waker::noop();
+    let mut cx = Context::from_waker(&waker);
+
+    let fut = pin!(async {
+        test_async_drop(test_async_drop(0)).await;
+    });
+    fut.poll(&mut cx);
+}

tests/crashes/132960.rs

@@ -0,0 +1,36 @@
+//@ known-bug: #132960
+
+#![feature(adt_const_params, const_ptr_read, generic_const_exprs)]
+
+const fn concat_strs<const A: &'static str, const B: &'static str>() -> &'static str
+where
+    [(); A.len()]:,
+    [(); B.len()]:,
+    [(); A.len() + B.len()]:,
+{
+    #[repr(C)]
+    #[repr(C)]
+
+    const fn concat_arr<const M: usize, const N: usize>(a: [u8; M], b: [u8; N]) -> [u8; M + N] {}
+
+    struct Inner<const A: &'static str, const B: &'static str>;
+    impl<const A: &'static str, const B: &'static str> Inner<A, B>
+    where
+        [(); A.len()]:,
+        [(); B.len()]:,
+        [(); A.len() + B.len()]:,
+    {
+        const ABSTR: &'static str = unsafe {
+            std::str::from_utf8_unchecked(&concat_arr(
+                A.as_ptr().cast().read(),
+                B.as_ptr().cast().read(),
+            ))
+        };
+    }
+
+    Inner::<A, B>::ABSTR
+}
+
+const FOO: &str = "foo";
+const BAR: &str = "bar";
+const FOOBAR: &str = concat_strs::<FOO, BAR>();

tests/crashes/133117.rs

@@ -0,0 +1,8 @@
+//@ known-bug: #133117
+
+fn main() {
+    match () {
+        (!|!) if true => {}
+        (!|!) if true => {}
+    }
+}

tests/crashes/133252.rs

@@ -0,0 +1,43 @@
+//@ known-bug: #133252
+//@ edition:2021
+use std::future::Future;
+
+trait Owned: 'static {}
+fn ice() -> impl Future<Output = &'static dyn Owned> {
+    async {
+        let not_static = 0;
+        force_send(async_load(&not_static));
+        loop {}
+    }
+}
+
+fn force_send<T: Send>(_: T) {}
+
+fn async_load<'a, T: LoadQuery<'a>>(this: T) -> impl Future {
+    async {
+        this.get_future().await;
+    }
+}
+
+trait LoadQuery<'a>: Sized {
+    type LoadFuture: Future;
+
+    fn get_future(self) -> Self::LoadFuture {
+        loop {}
+    }
+}
+
+impl<'a> LoadQuery<'a> for &'a u8 {
+    type LoadFuture = SimpleFuture;
+}
+
+struct SimpleFuture;
+impl Future for SimpleFuture {
+    type Output = ();
+    fn poll(
+        self: std::pin::Pin<&mut Self>,
+        _: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        loop {}
+    }
+}

tests/crashes/133613.rs

@@ -0,0 +1,7 @@
+//@ known-bug: #133613
+
+struct Wrapper<'a>();
+
+trait IntFactory {
+    fn stream(&self) -> impl IntFactory<stream(..): IntFactory<stream(..): Send>>;
+}

tests/crashes/134174.rs

@@ -0,0 +1,17 @@
+//@ known-bug: #134175
+//@compile-flags: -Zvalidate-mir -Zinline-mir=yes
+use std::vec::IntoIter;
+
+pub(crate) trait Foo: Iterator<Item = <Self as Foo>::Key> {
+    type Key;
+}
+
+impl Foo for IntoIter<i16> {}
+
+fn sum_foo<F: Foo<Key = i32>>(f: F) -> i32 {
+    f.fold(0, |a, b| a + b)
+}
+
+fn main() {
+    let x = sum_foo(vec![11, 10, 1].into_iter());
+}

tests/crashes/134334.rs

@@ -0,0 +1,9 @@
+//@ known-bug: #134334
+//@ only-x86_64
+
+#[repr(simd)]
+struct A();
+
+fn main() {
+    std::arch::asm!("{}", in(xmm_reg) A());
+}

tests/crashes/134335.rs

@@ -0,0 +1,12 @@
+//@ known-bug: #134335
+//@compile-flags: -Zunstable-options --edition=2024 --crate-type=lib
+pub async fn async_closure(x: &mut i32) {
+    let c = async move || {
+        *x += 1;
+    };
+    call_once(c).await;
+}
+
+fn call_once<T>(f: impl FnOnce() -> T) -> T {
+    f()
+}

tests/ui/associated-consts/issue-93775.rs

@@ -1,3 +1,7 @@
+//@ ignore-windows-msvc
+// FIXME(#132111, #133432): this test is flaky on windows msvc, it sometimes fail but it sometimes
+// passes.
+
 //@ build-pass
 // ignore-tidy-linelength
 

tests/ui/check-cfg/report-in-external-macros.cargo.stderr

@@ -6,7 +6,7 @@ LL |     cfg_macro::my_lib_macro!();
    |
    = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
-   = help: try refering to `cfg_macro::my_lib_macro` crate for guidance on how handle this unexpected cfg
+   = help: try referring to `cfg_macro::my_lib_macro` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
@@ -20,7 +20,7 @@ LL |     cfg_macro::my_lib_macro_value!();
    |
    = note: expected values for `panic` are: `abort` and `unwind`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
-   = help: try refering to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
+   = help: try referring to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro_value` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `cfg_macro::my_lib_macro_value` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -33,7 +33,7 @@ LL |     cfg_macro::my_lib_macro_feature!();
    |
    = note: no expected values for `feature`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
-   = help: try refering to `cfg_macro::my_lib_macro_feature` crate for guidance on how handle this unexpected cfg
+   = help: try referring to `cfg_macro::my_lib_macro_feature` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro_feature` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `cfg_macro::my_lib_macro_feature` (in Nightly builds, run with -Z macro-backtrace for more info)