Batched collector checkpoint

changes/20261028T105419Z/rust-lang--rust-part011-00000.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02e0f11e994bc8d159150d2e5b1105b099000b062eceedc2971e12a3b985268f
+size 6725081

patches/20261028T105419Z/rust-lang--rust-part011/07d97873828a24fe06c6eae2feff45f10518f089.patch

@@ -0,0 +1,94 @@
+diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
+index 4e111d01b637bde062b991accae7c5d607228411..c482d05b1e463cebabc8902e016fbf10e4aaa069 100644
+--- a/compiler/rustc_resolve/src/late.rs
++++ b/compiler/rustc_resolve/src/late.rs
+@@ -287,7 +287,8 @@ impl RibKind<'_> {
+ #[derive(Debug)]
+ pub(crate) struct Rib<'ra, R = Res> {
+     pub bindings: FxIndexMap<Ident, R>,
+-    pub patterns_with_skipped_bindings: UnordMap<DefId, Vec<(Span, Result<(), ErrorGuaranteed>)>>,
++    pub patterns_with_skipped_bindings:
++        UnordMap<DefId, Vec<(Span, Option<Span>, Result<(), ErrorGuaranteed>)>>,
+     pub kind: RibKind<'ra>,
+ }
+ 
+@@ -4363,6 +4364,10 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
+                         .or_default()
+                         .push((
+                             pat.span,
++                            match rest {
++                                ast::PatFieldsRest::Rest(span) => Some(*span),
++                                _ => None,
++                            },
+                             match rest {
+                                 ast::PatFieldsRest::Recovered(guar) => Err(*guar),
+                                 _ => Ok(()),
+diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
+index 3521419cc5de6954c026722244e75d713df113eb..0046ccdba6ec48a288595657f9d061e9aa8d382e 100644
+--- a/compiler/rustc_resolve/src/late/diagnostics.rs
++++ b/compiler/rustc_resolve/src/late/diagnostics.rs
+@@ -1602,11 +1602,11 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
+                 {
+                     for field in fields {
+                         if field.name == segment.ident.name {
+-                            if spans.iter().all(|(_, had_error)| had_error.is_err()) {
++                            if spans.iter().all(|(.., had_error)| had_error.is_err()) {
+                                 // This resolution error will likely be fixed by fixing a
+                                 // syntax error in a pattern, so it is irrelevant to the user.
+                                 let multispan: MultiSpan =
+-                                    spans.iter().map(|(s, _)| *s).collect::<Vec<_>>().into();
++                                    spans.iter().map(|(s, ..)| *s).collect::<Vec<_>>().into();
+                                 err.span_note(
+                                     multispan,
+                                     "this pattern had a recovered parse error which likely lost \
+@@ -1615,7 +1615,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
+                                 err.downgrade_to_delayed_bug();
+                             }
+                             let ty = self.r.tcx.item_name(*def_id);
+-                            for (span, _) in spans {
++                            for (span, rest_span, _) in spans {
+                                 err.span_label(
+                                     *span,
+                                     format!(
+@@ -1623,6 +1623,14 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
+                                          available in `{ty}`",
+                                     ),
+                                 );
++                                if let Some(rest_span) = rest_span {
++                                    err.span_suggestion_verbose(
++                                        *rest_span,
++                                        format!("include `{field}` in the pattern"),
++                                        format!("{field}, .."),
++                                        Applicability::MaybeIncorrect,
++                                    );
++                                }
+                             }
+                         }
+                     }
+diff --git a/tests/ui/pattern/struct-pattern-with-missing-fields-resolve-error.stderr b/tests/ui/pattern/struct-pattern-with-missing-fields-resolve-error.stderr
+index e588ffd388690808e307fd0be3802571d50ab355..d2047c4102d156e2785490ae3d2ea28cc8dc8b06 100644
+--- a/tests/ui/pattern/struct-pattern-with-missing-fields-resolve-error.stderr
++++ b/tests/ui/pattern/struct-pattern-with-missing-fields-resolve-error.stderr
+@@ -13,6 +13,11 @@ LL |     if let Website { url, .. } = website {
+    |            ------------------- this pattern doesn't include `title`, which is available in `Website`
+ LL |         println!("[{}]({})", title, url);
+    |                              ^^^^^ not found in this scope
++   |
++help: include `title` in the pattern
++   |
++LL |     if let Website { url, title, .. } = website {
++   |                           ++++++
+ 
+ error[E0425]: cannot find value `a` in this scope
+   --> $DIR/struct-pattern-with-missing-fields-resolve-error.rs:28:20
+@@ -22,6 +27,10 @@ LL |     if let Foo::Bar { .. } = x {
+ LL |         println!("{a}");
+    |                    ^ not found in this scope
+    |
++help: include `a` in the pattern
++   |
++LL |     if let Foo::Bar { a, .. } = x {
++   |                       ++
+ help: a local variable with a similar name exists
+    |
+ LL -         println!("{a}");

patches/20261028T105419Z/rust-lang--rust-part011/09c7d6fab3648d715c3ae00cc37b96c8f3f9bb93.patch

@@ -0,0 +1,43 @@
+diff --git a/.github/workflows/clippy_mq.yml b/.github/workflows/clippy_mq.yml
+index 43cab49d8ece60f6829b0a8167992571dacce8f4..3dd4a5abe8f3a7a40d28b8862a920c902f1ebfb6 100644
+--- a/.github/workflows/clippy_mq.yml
++++ b/.github/workflows/clippy_mq.yml
+@@ -147,7 +147,6 @@ jobs:
+       max-parallel: 6
+       matrix:
+         integration:
+-        - 'matthiaskrgr/clippy_ci_panic_test'
+         - 'rust-lang/cargo'
+         - 'rust-lang/chalk'
+         - 'rust-lang/rustfmt'
+diff --git a/tests/integration.rs b/tests/integration.rs
+index 4275292fd86e616c31cef1eaab5b48e80eb63e0b..06e87c17d283a3288ac5bba242cc3403ad6d1aa9 100644
+--- a/tests/integration.rs
++++ b/tests/integration.rs
+@@ -61,26 +61,6 @@ fn integration_test() {
+     // debug:
+     eprintln!("{stderr}");
+ 
+-    // this is an internal test to make sure we would correctly panic on a span_delayed_bug
+-    if repo_name == "matthiaskrgr/clippy_ci_panic_test" {
+-        // we need to kind of switch around our logic here:
+-        // if we find a panic, everything is fine, if we don't panic, SOMETHING is broken about our testing
+-
+-        // the repo basically just contains a span_delayed_bug that forces rustc/clippy to panic:
+-        /*
+-           #![feature(rustc_attrs)]
+-           #[rustc_error(delayed_bug_from_inside_query)]
+-           fn main() {}
+-        */
+-
+-        if stderr.find("error: internal compiler error").is_some() {
+-            eprintln!("we saw that we intentionally panicked, yay");
+-            return;
+-        }
+-
+-        panic!("panic caused by span_delayed_bug was NOT detected! Something is broken!");
+-    }
+-
+     if let Some(backtrace_start) = stderr.find("error: internal compiler error") {
+         static BACKTRACE_END_MSG: &str = "end of query stack";
+         let backtrace_end = stderr[backtrace_start..]

patches/20261028T105419Z/rust-lang--rust-part011/0a7c6f478a73b06c3cdb8ce642b05189e0299f68.patch

@@ -0,0 +1,28 @@
+diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
+index 549dcc24cfa9a74c4c5f18052179bb010c645b5b..f7eb76bbe72b5cc2c56e6ec7ea67e6c20c2d6d08 100644
+--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
++++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
+@@ -21,7 +21,11 @@ use crate::traits::{FulfillmentError, ScrubbedTraitError};
+ 
+ mod derive_errors;
+ 
+-// FIXME: Do we need to use a `ThinVec` here?
++// `ThinVec` is important for performance, but not for the usual memory layout reasons.
++// `try_evaluate_obligations` is extremely hot and uses `retain_mut`. `ThinVec::retain_mut` is
++// simple and sub-optimal in terms of how it moves elements, but it can be inlined.
++// `Vec::retain_mut` is more sophisticated and minimizes element moves, but also contains more code
++// and doesn't get inlined in `try_evaluate_obligations`, giving worse performance overall.
+ type PendingObligations<'tcx> =
+     ThinVec<(PredicateObligation<'tcx>, Option<GoalStalledOn<TyCtxt<'tcx>>>)>;
+ 
+@@ -453,7 +457,9 @@ mod size_asserts {
+     use super::*;
+     // tidy-alphabetical-start
+     // Before #160005 this pair was greater than 128 bytes, which triggered the use of (slow)
+-    // `memcpy` for moving elements of `PendingObligations`.
++    // `memcpy` for moving elements of `PendingObligations`. Then #160479 greatly reduced the
++    // number of `memcpy` operations in `try_evaluate_obligations`. So the size of this pair is
++    // much less important than it was, but still shouldn't be changed without some thought.
+     static_assert_size!((PredicateObligation<'_>, Option<GoalStalledOn<TyCtxt<'_>>>), 104);
+     // tidy-alphabetical-end
+ }

patches/20261028T105419Z/rust-lang--rust-part011/2686c8c0128c0cd672f5b6df5603f7743f64b846.patch

@@ -0,0 +1,158 @@
+diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
+index 03d13e6a81a6e88b3a496a7448003b926000e226..ee8d8659e66e1e507bc4dabb05734377fba7661b 100644
+--- a/compiler/rustc_middle/src/ty/print/pretty.rs
++++ b/compiler/rustc_middle/src/ty/print/pretty.rs
+@@ -2692,15 +2692,10 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
+ struct RegionFolder<'a, 'tcx> {
+     tcx: TyCtxt<'tcx>,
+     current_index: ty::DebruijnIndex,
++    /// Regions bound by the binder being named (and placeholders) that have
++    /// already been named.
+     region_map: UnordMap<ty::BoundRegion<'tcx>, ty::Region<'tcx>>,
+-    name: &'a mut (
+-                dyn FnMut(
+-        Option<ty::DebruijnIndex>, // Debruijn index of the folded late-bound region
+-        ty::DebruijnIndex,         // Index corresponding to binder level
+-        ty::BoundRegion<'tcx>,
+-    ) -> ty::Region<'tcx>
+-                    + 'a
+-            ),
++    name: &'a mut (dyn FnMut(ty::BoundRegion<'tcx>) -> ty::Region<'tcx> + 'a),
+ }
+ 
+ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
+@@ -2731,8 +2726,13 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
+     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+         let name = &mut self.name;
+         let region = match r.kind() {
+-            ty::ReBound(ty::BoundVarIndexKind::Bound(db), br) if db >= self.current_index => {
+-                *self.region_map.entry(br).or_insert_with(|| name(Some(db), self.current_index, br))
++            // Only name regions bound by the binder being named. Regions bound by an
++            // enclosing binder that merely escape through this one keep their name
++            // (they were named when that binder was folded) and their index, and must
++            // not end up in `region_map`, which callers use to build `for<...>` lists
++            // (#102392, #134410).
++            ty::ReBound(ty::BoundVarIndexKind::Bound(db), br) if db == self.current_index => {
++                *self.region_map.entry(br).or_insert_with(|| name(br))
+             }
+             ty::RePlaceholder(ty::PlaceholderRegion {
+                 bound: ty::BoundRegion { kind, .. },
+@@ -2745,10 +2745,7 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
+                     _ => {
+                         // Index doesn't matter, since this is just for naming and these never get bound
+                         let br = ty::BoundRegion { var: ty::BoundVar::ZERO, kind };
+-                        *self
+-                            .region_map
+-                            .entry(br)
+-                            .or_insert_with(|| name(None, self.current_index, br))
++                        *self.region_map.entry(br).or_insert_with(|| name(br))
+                     }
+                 }
+             }
+@@ -2857,13 +2854,8 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
+ 
+             let trim_path = with_forced_trimmed_paths();
+             // Closure used in `RegionFolder` to create names for anonymous late-bound
+-            // regions. We use two `DebruijnIndex`es (one for the currently folded
+-            // late-bound region and the other for the binder level) to determine
+-            // whether a name has already been created for the currently folded region,
+-            // see issue #102392.
+-            let mut name = |lifetime_idx: Option<ty::DebruijnIndex>,
+-                            binder_level_idx: ty::DebruijnIndex,
+-                            br: ty::BoundRegion<'tcx>| {
++            // regions.
++            let mut name = |br: ty::BoundRegion<'tcx>| {
+                 let (name, kind) = if let Some(name) = br.kind.get_name(tcx) {
+                     (name, br.kind)
+                 } else {
+@@ -2871,16 +2863,6 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
+                     (name, ty::BoundRegionKind::NamedForPrinting(name))
+                 };
+ 
+-                if let Some(lt_idx) = lifetime_idx {
+-                    if lt_idx > binder_level_idx {
+-                        return ty::Region::new_bound(
+-                            tcx,
+-                            ty::INNERMOST,
+-                            ty::BoundRegion { var: br.var, kind },
+-                        );
+-                    }
+-                }
+-
+                 // Unconditionally render `unsafe<>`.
+                 if !trim_path || mode == WrapBinderMode::Unsafe {
+                     start_or_continue(self, mode.start_str(), ", ");
+diff --git a/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.rs b/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..65620812e3f8a742e117584935574a17564d2154
+--- /dev/null
++++ b/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.rs
+@@ -0,0 +1,26 @@
++//! Regression test for <https://github.com/rust-lang/rust/issues/134410> and
++//! <https://github.com/rust-lang/rust/issues/111365>.
++//!
++//! The expected/found notes of "one type is more general than the other" errors
++//! used to leak lifetimes bound by outer binders into nested `for<...>` lists,
++//! printing invalid types such as `&mut for<'a> fn(for<'a> fn(&'a ()))` or
++//! `for<'o> fn(for<'a, 'o> fn(&'a (), &'o ()))`.
++
++type F1 = fn(fn(&'static ()));
++type F2 = for<'a> fn(fn(&'a ()));
++
++fn issue_134410(a: &mut F1) {
++    let _: &mut F2 = a; //~ ERROR mismatched types
++}
++
++type One = fn(HelperOne);
++type HelperOne = for<'a> fn(&'a (), &'a ());
++
++type Two = for<'o> fn(HelperTwo<'o>);
++type HelperTwo<'x> = for<'a> fn(&'a (), &'x ());
++
++fn issue_111365(x: One) -> Two {
++    x //~ ERROR mismatched types
++}
++
++fn main() {}
+diff --git a/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.stderr b/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.stderr
+new file mode 100644
+index 0000000000000000000000000000000000000000..c26b39ec5a567ed29e4129975df1febe00644829
+--- /dev/null
++++ b/tests/ui/higher-ranked/nested-binder-cmp-fn-sig-print.stderr
+@@ -0,0 +1,23 @@
++error[E0308]: mismatched types
++  --> $DIR/nested-binder-cmp-fn-sig-print.rs:23:5
++   |
++LL | fn issue_111365(x: One) -> Two {
++   |                            --- expected `for<'o> fn(for<'a> fn(&'a (), &'o ()))` because of return type
++LL |     x
++   |     ^ one type is more general than the other
++   |
++   = note: expected fn pointer `for<'o> fn(for<'a> fn(&'a (), &'o ()))`
++              found fn pointer `fn(for<'a> fn(&'a (), &'a ()))`
++
++error[E0308]: mismatched types
++  --> $DIR/nested-binder-cmp-fn-sig-print.rs:13:22
++   |
++LL |     let _: &mut F2 = a;
++   |                      ^ one type is more general than the other
++   |
++   = note: expected mutable reference `&mut for<'a> fn(fn(&'a ()))`
++              found mutable reference `&mut fn(fn(&()))`
++
++error: aborting due to 2 previous errors
++
++For more information about this error, try `rustc --explain E0308`.
+diff --git a/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr b/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr
+index 80ab5c8d6e9d8b28a47ad57a78e7d5c6d388e0c2..05950c4d4f48aeb8154bc6d37a2ef1d573d2e115 100644
+--- a/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr
++++ b/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr
+@@ -5,7 +5,7 @@ LL |     x
+    |     ^ one type is more general than the other
+    |
+    = note: expected fn pointer `fn(fn(fn(for<'unify> fn(Contra<'unify>, Co<'unify>))))`
+-              found fn pointer `for<'e> fn(for<'e, 'p> fn(for<'e, 'p> fn(for<'e, 'p> fn(Contra<'e>, Co<'p>))))`
++              found fn pointer `for<'e> fn(for<'p> fn(fn(fn(Contra<'e>, Co<'p>))))`
+ 
+ error: lifetime may not live long enough
+   --> $DIR/placeholder-outlives-existential.rs:28:5

patches/20261028T105419Z/rust-lang--rust-part011/26b5b02b77dcf30e1f20f657211afaab7eedbee8.patch

@@ -0,0 +1,188 @@
+diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
+index 2ea3a84bdc7109dd76f187d0464bd30f9745092c..59013ca820d9c2b95454ed58c7b6dc8a0a1c9708 100644
+--- a/clippy_dev/src/edit_lints.rs
++++ b/clippy_dev/src/edit_lints.rs
+@@ -333,7 +333,7 @@ fn uplift_update_fn<'a>(
+         while let Some(ident) = cursor.find_any_ident() {
+             match cursor.get_text(ident) {
+                 "mod"
+-                    if remove_mod && cursor.match_all(&[cursor::Pat::Ident(old_name), cursor::Pat::Semi], &mut []) =>
++                    if remove_mod && cursor.match_ident(old_name).is_some() && cursor.match_pat(cursor::Pat::Semi) =>
+                 {
+                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
+                     dst.push_str(new_name);
+@@ -343,7 +343,7 @@ fn uplift_update_fn<'a>(
+                     }
+                     changed = true;
+                 },
+-                "clippy" if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::Ident(old_name)], &mut []) => {
++                "clippy" if cursor.match_pat(cursor::Pat::DoubleColon) && cursor.match_ident(old_name).is_some() => {
+                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
+                     dst.push_str(new_name);
+                     copy_pos = cursor.pos();
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index ff6c63f61d8665701bc617f9fc820ab2a4fb8d42..d4e7fdfdba52175945e3961f44d2aa59dd07946b 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -1,6 +1,6 @@
+ pub mod cursor;
+ 
+-use self::cursor::{Capture, Cursor};
++use self::cursor::{Capture, Cursor, IdentPat};
+ use crate::utils::{ErrAction, File, Scoped, expect_action, slice_groups_mut, walk_dir_no_dot_or_target};
+ use core::cell::Cell;
+ use core::fmt::{self, Display, Write as _};
+@@ -352,16 +352,17 @@ impl<'cx> ParseCxImpl<'cx> {
+         #[allow(clippy::enum_glob_use)]
+         use cursor::Pat::*;
+         #[rustfmt::skip]
+-        static LINT_DECL_TOKENS: &[cursor::Pat<'_>] = &[
++        static LINT_DECL_TOKENS: &[cursor::Pat] = &[
+             // !{ /// docs
+             Bang, OpenBrace, AnyComment,
+             // #[clippy::version = "version"]
+-            Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, LitStr, CloseBracket,
++            Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
++            Ident(IdentPat::version), Eq, LitStr, CloseBracket,
+             // pub NAME, GROUP,
+-            Ident("pub"), CaptureIdent, Comma, AnyComment, CaptureIdent, Comma,
++            Ident(IdentPat::r#pub), CaptureIdent, Comma, AnyComment, CaptureIdent, Comma,
+         ];
+         #[rustfmt::skip]
+-        static PASS_DECL_TOKENS: &[cursor::Pat<'_>] = &[
++        static PASS_DECL_TOKENS: &[cursor::Pat] = &[
+             // !( NAME <'lt> => [
+             Bang, OpenParen, CaptureDocLines, CaptureIdent, CaptureOptLifetimeArg, FatArrow, OpenBracket,
+         ];
+@@ -453,22 +454,26 @@ impl<'cx> ParseCxImpl<'cx> {
+     fn parse_deprecated_lints(&mut self, data: &mut LintData<'cx>) {
+         #[allow(clippy::enum_glob_use)]
+         use cursor::Pat::*;
++
+         #[rustfmt::skip]
+-        static DECL_TOKENS: &[cursor::Pat<'_>] = &[
++        static DECL_TOKENS: &[cursor::Pat] = &[
+             // #[clippy::version = "version"]
+-            Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, CaptureLitStr, CloseBracket,
++            Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
++            Ident(IdentPat::version), Eq, CaptureLitStr, CloseBracket,
+             // ("first", "second"),
+             OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen, Comma,
+         ];
+         #[rustfmt::skip]
+-        static DEPRECATED_TOKENS: &[cursor::Pat<'_>] = &[
++        static DEPRECATED_TOKENS: &[cursor::Pat] = &[
+             // !{ DEPRECATED(DEPRECATED_VERSION) = [
+-            Bang, OpenBrace, Ident("DEPRECATED"), OpenParen, Ident("DEPRECATED_VERSION"), CloseParen, Eq, OpenBracket,
++            Bang, OpenBrace, Ident(IdentPat::DEPRECATED), OpenParen,
++            Ident(IdentPat::DEPRECATED_VERSION), CloseParen, Eq, OpenBracket,
+         ];
+         #[rustfmt::skip]
+-        static RENAMED_TOKENS: &[cursor::Pat<'_>] = &[
++        static RENAMED_TOKENS: &[cursor::Pat] = &[
+             // !{ RENAMED(RENAMED_VERSION) = [
+-            Bang, OpenBrace, Ident("RENAMED"), OpenParen, Ident("RENAMED_VERSION"), CloseParen, Eq, OpenBracket,
++            Bang, OpenBrace, Ident(IdentPat::RENAMED), OpenParen,
++            Ident(IdentPat::RENAMED_VERSION), CloseParen, Eq, OpenBracket,
+         ];
+ 
+         let file = data.deprecated_file;
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index af840532c27bd0e9472c6eaa0438ba97841561db..5a30931040a323383ecca651979c70934ca49d3c 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -8,10 +8,10 @@ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+ /// `DoubleColon` will consume the first `:` and then fail to match, leaving the cursor at
+ /// the `*`.
+ #[derive(Clone, Copy)]
+-pub enum Pat<'a> {
++pub enum Pat {
++    Ident(IdentPat),
+     /// Matches any number of comments and doc comments.
+     AnyComment,
+-    Ident(&'a str),
+     CaptureDocLines,
+     CaptureIdent,
+     LitStr,
+@@ -35,6 +35,36 @@ pub enum Pat<'a> {
+     Semi,
+ }
+ 
++macro_rules! ident_or_lit {
++    ($ident:ident) => {
++        stringify!($ident)
++    };
++    ($_ident:ident $lit:literal) => {
++        $lit
++    };
++}
++macro_rules! decl_ident_pats {
++    ($($ident:ident $(= $s:literal)?,)*) => {
++        #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
++        #[derive(Clone, Copy)]
++        pub enum IdentPat { $($ident),* }
++        impl IdentPat {
++            pub fn as_str(self) -> &'static str {
++                match self { $(Self::$ident => ident_or_lit!($ident $($s)?)),* }
++            }
++        }
++    }
++}
++decl_ident_pats! {
++    DEPRECATED,
++    DEPRECATED_VERSION,
++    RENAMED,
++    RENAMED_VERSION,
++    clippy,
++    r#pub = "pub",
++    version,
++}
++
+ #[derive(Clone, Copy)]
+ pub struct Capture {
+     pub pos: u32,
+@@ -116,7 +146,7 @@ impl<'txt> Cursor<'txt> {
+     /// For each capture made by the pattern one item will be taken from the capture
+     /// sequence with the result placed inside.
+     #[expect(clippy::too_many_lines)]
+-    fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_, Capture>) -> bool {
++    fn match_impl(&mut self, pat: Pat, captures: &mut slice::IterMut<'_, Capture>) -> bool {
+         loop {
+             match (pat, self.next_token.kind) {
+                 #[rustfmt::skip] // rustfmt bug: https://github.com/rust-lang/rustfmt/issues/6697
+@@ -149,7 +179,7 @@ impl<'txt> Cursor<'txt> {
+                     self.step();
+                     return true;
+                 },
+-                (Pat::Ident(x), TokenKind::Ident) if x == self.peek_text() => {
++                (Pat::Ident(x), TokenKind::Ident) if x.as_str() == self.peek_text() => {
+                     self.step();
+                     return true;
+                 },
+@@ -319,7 +349,7 @@ impl<'txt> Cursor<'txt> {
+     /// Not generally suitable for multi-token patterns or patterns that can match
+     /// nothing.
+     #[must_use]
+-    pub fn find_pat(&mut self, pat: Pat<'_>) -> bool {
++    pub fn find_pat(&mut self, pat: Pat) -> bool {
+         let mut capture = [].iter_mut();
+         while !self.match_impl(pat, &mut capture) {
+             self.step();
+@@ -340,7 +370,7 @@ impl<'txt> Cursor<'txt> {
+     ///
+     /// If the match fails the cursor will be positioned at the first failing token.
+     #[must_use]
+-    pub fn match_all(&mut self, pats: &[Pat<'_>], captures: &mut [Capture]) -> bool {
++    pub fn match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> bool {
+         let mut captures = captures.iter_mut();
+         pats.iter().all(|&p| self.match_impl(p, &mut captures))
+     }
+@@ -351,7 +381,7 @@ impl<'txt> Cursor<'txt> {
+     /// If the pattern attempts to capture anything this will panic. If the match fails
+     /// the cursor will be positioned at the first failing token.
+     #[must_use]
+-    pub fn match_pat(&mut self, pat: Pat<'_>) -> bool {
++    pub fn match_pat(&mut self, pat: Pat) -> bool {
+         self.match_impl(pat, &mut [].iter_mut())
+     }
+ }

patches/20261028T105419Z/rust-lang--rust-part011/44ec893f6f4d0f528c5e5c131bb19d84995f2ebb.patch

@@ -0,0 +1,30 @@
+diff --git a/tests/codegen-llvm/issues/static-table-search-loop-44041.rs b/tests/codegen-llvm/issues/static-table-search-loop-44041.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..cbdfcd088aa1180792305b4fdec624ff5880367f
+--- /dev/null
++++ b/tests/codegen-llvm/issues/static-table-search-loop-44041.rs
+@@ -0,0 +1,24 @@
++// Tests that a loop searching a small static array is unrolled and simplified
++// down to a single comparison, with none of the unrolled branches left behind.
++// See <https://github.com/rust-lang/rust/issues/44041>.
++
++//@ compile-flags: -Copt-level=3
++
++#![crate_type = "lib"]
++
++static TABLE: [i32; 4] = [0; 4];
++
++// CHECK-LABEL: @exists_in_table(
++// CHECK-NOT: br {{.*}}
++// CHECK: icmp eq i32
++// CHECK-NOT: br {{.*}}
++// CHECK: ret i1
++#[no_mangle]
++pub fn exists_in_table(v: i32) -> bool {
++    for &x in TABLE.iter() {
++        if x == v {
++            return true;
++        }
++    }
++    false
++}

patches/20261028T105419Z/rust-lang--rust-part011/47562f99ac1bdeab3ad8c0d92dc0619cf4adf820.patch

@@ -0,0 +1,457 @@
+diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
+index 9307fb41b6ea5a57aab7fba604d6ca78189c0db0..4ced81f5b1d3dc85f2cd26758ee7678cb282d131 100644
+--- a/clippy_dev/src/edit_lints.rs
++++ b/clippy_dev/src/edit_lints.rs
+@@ -1,5 +1,7 @@
+ use crate::parse::cursor::{self, Capture, Cursor};
+-use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, RenamedLint};
++use crate::parse::{
++    ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, ParsedLints, RenamedLint, SourceFile, Span,
++};
+ use crate::utils::{
+     ErrAction, FileUpdater, UpdateMode, UpdateStatus, Version, delete_dir_if_exists, delete_file_if_exists,
+     expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
+@@ -27,18 +29,28 @@ pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name
+         eprintln!("error: failed to find lint `{name}`");
+         return;
+     };
+-    let Lint::Active(prev_lint) = mem::replace(
++    let prev_lint = mem::replace(
+         lint.get_mut(),
+-        Lint::Deprecated(DeprecatedLint {
+-            reason,
+-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+-        }),
+-    ) else {
++        Lint {
++            name_sp: Span::new(data.deprecated_file, 0..0),
++            data: LintData::Deprecated(DeprecatedLint {
++                reason,
++                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
++            }),
++        },
++    );
++    let LintData::Active(prev_lint_data) = prev_lint.data else {
+         eprintln!("error: `{name}` is already deprecated");
+         return;
+     };
+ 
+-    remove_lint_declaration(name, &prev_lint, &data, &mut FileUpdater::default());
++    remove_lint_declaration(
++        name,
++        prev_lint.name_sp.file,
++        &prev_lint_data,
++        &data,
++        &mut FileUpdater::default(),
++    );
+     data.gen_decls(UpdateMode::Change);
+     println!("info: `{name}` has successfully been deprecated");
+     println!("note: you must run `cargo uitest` to update the test results");
+@@ -53,19 +65,24 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+         eprintln!("error: failed to find lint `{old_name}`");
+         return;
+     };
+-    let Lint::Active(prev_lint) = mem::replace(
++
++    let prev_lint = mem::replace(
+         lint.get_mut(),
+-        Lint::Renamed(RenamedLint {
+-            new_name: LintName::new_rustc(new_name),
+-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+-        }),
+-    ) else {
++        Lint {
++            name_sp: Span::new(data.deprecated_file, 0..0),
++            data: LintData::Renamed(RenamedLint {
++                new_name: LintName::new_rustc(new_name),
++                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
++            }),
++        },
++    );
++    let LintData::Active(prev_lint_data) = prev_lint.data else {
+         eprintln!("error: `{old_name}` is already deprecated");
+         return;
+     };
+ 
+     let mut updater = FileUpdater::default();
+-    let remove_mod = remove_lint_declaration(old_name, &prev_lint, &data, &mut updater);
++    let remove_mod = remove_lint_declaration(old_name, prev_lint.name_sp.file, &prev_lint_data, &data, &mut updater);
+     let mut update_fn = uplift_update_fn(old_name, new_name, remove_mod);
+     for e in walk_dir_no_dot_or_target(".") {
+         let e = expect_action(e, ErrAction::Read, ".");
+@@ -103,32 +120,38 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+         eprintln!("error: failed to find lint `{old_name}`");
+         return;
+     };
+-    let Lint::Active(prev_lint) = mem::replace(
++
++    let prev_lint = mem::replace(
+         lint.get_mut(),
+-        Lint::Renamed(RenamedLint {
+-            new_name: LintName::new_clippy(new_name),
+-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+-        }),
+-    ) else {
++        Lint {
++            name_sp: Span::new(data.deprecated_file, 0..0),
++            data: LintData::Renamed(RenamedLint {
++                new_name: LintName::new_clippy(new_name),
++                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
++            }),
++        },
++    );
++    if !matches!(prev_lint.data, LintData::Active(_)) {
+         eprintln!("error: `{old_name}` is already deprecated");
+         return;
+     };
+ 
++    let prev_file = prev_lint.name_sp.file;
+     let mut rename_mod = false;
+     if let Entry::Vacant(e) = data.lints.entry(new_name) {
+-        if let Some((path, file)) = prev_lint.file.path.get().rsplit_once(path::MAIN_SEPARATOR)
++        if let Some((path, file)) = prev_file.path.get().rsplit_once(path::MAIN_SEPARATOR)
+             && let Some(file) = file.strip_suffix(".rs")
+             && file == old_name
+         {
+             let new_path = cx
+                 .str_buf
+                 .alloc_display(cx.arena, format_args!("{path}{}{new_name}.rs", path::MAIN_SEPARATOR));
+-            if try_rename_file(prev_lint.file.path.get(), new_path) {
++            if try_rename_file(prev_file.path.get(), new_path) {
+                 rename_mod = true;
+-                prev_lint.file.path.set(new_path);
++                prev_file.path.set(new_path);
+             }
+         }
+-        e.insert(Lint::Active(prev_lint));
++        e.insert(prev_lint);
+         rename_test_files(old_name, new_name, &create_ignored_prefixes(old_name, &data));
+     } else {
+         println!("Renamed `{old_name}` to `{new_name}`");
+@@ -153,22 +176,22 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+ 
+ /// Removes a lint's declaration and test files. Returns whether the module containing the
+ /// lint was deleted.
+-fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &LintData<'_>, updater: &mut FileUpdater) -> bool {
+-    let delete_mod = if data.lints.iter().all(|(_, l)| {
+-        if let Lint::Active(l) = l {
+-            l.file != lint.file
+-        } else {
+-            true
+-        }
+-    }) {
+-        delete_file_if_exists(lint.file.path.get())
++fn remove_lint_declaration(
++    name: &str,
++    lint_file: &SourceFile<'_>,
++    lint_data: &ActiveLint<'_>,
++    data: &ParsedLints<'_>,
++    updater: &mut FileUpdater,
++) -> bool {
++    let delete_mod = if data.lints.iter().all(|(_, l)| l.name_sp.file != lint_file) {
++        delete_file_if_exists(lint_file.path.get())
+     } else {
+-        updater.update_file(lint.file.path.get(), &mut |_, src, dst| -> UpdateStatus {
+-            let mut start = &src[..lint.declaration_range.start as usize];
++        updater.update_file(lint_file.path.get(), &mut |_, src, dst| -> UpdateStatus {
++            let mut start = &src[..lint_data.decl_range.start as usize];
+             if start.ends_with("\n\n") {
+                 start = &start[..start.len() - 1];
+             }
+-            let mut end = &src[lint.declaration_range.end as usize..];
++            let mut end = &src[lint_data.decl_range.end as usize..];
+             if end.starts_with("\n\n") {
+                 end = &end[1..];
+             }
+@@ -187,10 +210,10 @@ fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &LintData<'_
+ ///
+ /// This is needed because rustc doesn't allow a lint to be renamed to a lint that has
+ /// also been renamed.
+-fn update_rename_targets<'cx>(data: &mut LintData<'cx>, old_name: &str, new_name: LintName<'cx>) {
++fn update_rename_targets<'cx>(data: &mut ParsedLints<'cx>, old_name: &str, new_name: LintName<'cx>) {
+     let old_name = LintName::new_clippy(old_name);
+     for lint in data.lints.values_mut() {
+-        if let Lint::Renamed(lint) = lint
++        if let LintData::Renamed(lint) = &mut lint.data
+             && lint.new_name == old_name
+         {
+             lint.new_name = new_name;
+@@ -199,7 +222,7 @@ fn update_rename_targets<'cx>(data: &mut LintData<'cx>, old_name: &str, new_name
+ }
+ 
+ /// Creates a list of prefixes to ignore when
+-fn create_ignored_prefixes<'cx>(name: &str, data: &LintData<'cx>) -> Vec<&'cx str> {
++fn create_ignored_prefixes<'cx>(name: &str, data: &ParsedLints<'cx>) -> Vec<&'cx str> {
+     data.lints
+         .keys()
+         .copied()
+diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
+index ba09dca6abd78e04c2aaf72cb23deff92c6f140a..ea136417425ba3ec9aebac0d44044de648ab99cc 100644
+--- a/clippy_dev/src/fmt.rs
++++ b/clippy_dev/src/fmt.rs
+@@ -344,7 +344,7 @@ pub fn run(update_mode: UpdateMode) {
+         let mut lints = data.mk_file_to_lint_decl_map();
+         let mut ranges = VecBuf::with_capacity(256);
+         for passes in data.iter_passes_by_file_mut() {
+-            let file = passes[0].file;
++            let file = passes[0].decl_sp.file;
+             let mut lints = lints.remove(file);
+             let lints = lints.as_deref_mut().unwrap_or_default();
+             updater.update_loaded_file_checked("cargo dev fmt", update_mode, file, &mut |_, src, dst| {
+diff --git a/clippy_dev/src/generate.rs b/clippy_dev/src/generate.rs
+index 2159900d580c81c869600035554ffb0ff0c94e54..fe11d87bf06553bdceb33402aa495c542bee4bb1 100644
+--- a/clippy_dev/src/generate.rs
++++ b/clippy_dev/src/generate.rs
+@@ -1,5 +1,5 @@
+ use crate::parse::cursor::Cursor;
+-use crate::parse::{Lint, LintData, LintPass, VecBuf};
++use crate::parse::{LintData, LintPass, ParsedLints, VecBuf};
+ use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, slice_groups, update_text_region_fn};
+ use core::range::Range;
+ use itertools::Itertools as _;
+@@ -13,7 +13,7 @@ const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev u
+ 
+ const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/main/index.html";
+ 
+-impl LintData<'_> {
++impl ParsedLints<'_> {
+     #[expect(clippy::too_many_lines)]
+     pub fn gen_decls(&self, update_mode: UpdateMode) {
+         let mut updater = FileUpdater::default();
+@@ -39,10 +39,10 @@ impl LintData<'_> {
+         let mut deprecated = Vec::with_capacity(lints.len() / 8);
+         let mut renamed = Vec::with_capacity(lints.len() / 8);
+         for &(name, lint) in &lints {
+-            match lint {
+-                Lint::Active(lint) => active.push((name, lint.file.path_as_krate_mod())),
+-                Lint::Deprecated(lint) => deprecated.push((name, lint)),
+-                Lint::Renamed(lint) => renamed.push((name, lint)),
++            match &lint.data {
++                LintData::Active(_) => active.push((name, lint.name_sp.file.path_as_krate_mod())),
++                LintData::Deprecated(lint) => deprecated.push((name, lint)),
++                LintData::Renamed(lint) => renamed.push((name, lint)),
+             }
+         }
+         active.sort_by_key(|&(_, path)| path);
+@@ -265,7 +265,7 @@ pub fn gen_sorted_lints_file(
+ ) {
+     ranges.with(|ranges| {
+         ranges.extend(lints.iter().map(|&(_, x)| x));
+-        ranges.extend(passes.iter().map(|x| x.decl_range));
++        ranges.extend(passes.iter().map(|x| x.decl_sp.range));
+         ranges.sort_unstable_by_key(|x| x.start);
+ 
+         lints.sort_unstable_by_key(|&(x, _)| x);
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index 609b12e4f1f0ea0e3b8bc43fb57f12c05cf71056..92edee2b37922b8fe7778c23783700ea76213969 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -69,6 +69,17 @@ impl Hash for SourceFile<'_> {
+     }
+ }
+ 
++#[derive(Clone, Copy)]
++pub struct Span<'cx> {
++    pub file: &'cx SourceFile<'cx>,
++    pub range: Range<u32>,
++}
++impl<'cx> Span<'cx> {
++    pub fn new(file: &'cx SourceFile<'cx>, range: Range<u32>) -> Self {
++        Self { file, range }
++    }
++}
++
+ pub struct ParseCxImpl<'cx> {
+     pub arena: &'cx DroplessArena,
+     pub source_files: &'cx TypedArena<SourceFile<'cx>>,
+@@ -218,9 +229,8 @@ impl Display for LintName<'_> {
+ }
+ 
+ pub struct ActiveLint<'cx> {
+-    pub file: &'cx SourceFile<'cx>,
+     pub group: &'cx str,
+-    pub declaration_range: Range<u32>,
++    pub decl_range: Range<u32>,
+ }
+ 
+ pub struct DeprecatedLint<'cx> {
+@@ -233,12 +243,17 @@ pub struct RenamedLint<'cx> {
+     pub version: &'cx str,
+ }
+ 
+-pub enum Lint<'cx> {
++pub enum LintData<'cx> {
+     Active(ActiveLint<'cx>),
+     Deprecated(DeprecatedLint<'cx>),
+     Renamed(RenamedLint<'cx>),
+ }
+ 
++pub struct Lint<'cx> {
++    pub name_sp: Span<'cx>,
++    pub data: LintData<'cx>,
++}
++
+ #[derive(Clone, Copy)]
+ pub enum LintPassMac {
+     Declare,
+@@ -260,27 +275,26 @@ pub struct LintPass<'cx> {
+     pub name: &'cx str,
+     pub lt: Option<&'cx str>,
+     pub mac: LintPassMac,
+-    pub file: &'cx SourceFile<'cx>,
+-    pub decl_range: Range<u32>,
++    pub decl_sp: Span<'cx>,
+     pub lints: &'cx mut [&'cx str],
+ }
+ 
+-pub struct LintData<'cx> {
++pub struct ParsedLints<'cx> {
+     pub lints: FxHashMap<&'cx str, Lint<'cx>>,
+     pub lint_passes: Vec<LintPass<'cx>>,
+     pub deprecated_file: &'cx SourceFile<'cx>,
+ }
+-impl<'cx> LintData<'cx> {
++impl<'cx> ParsedLints<'cx> {
+     #[expect(clippy::mutable_key_type)]
+     pub fn mk_file_to_lint_decl_map(&self) -> FxHashMap<&'cx SourceFile<'cx>, Vec<(&'cx str, Range<u32>)>> {
+         #[expect(clippy::default_trait_access)]
+         let mut lints = FxHashMap::with_capacity_and_hasher(500, Default::default());
+         for (&name, lint) in &self.lints {
+-            if let Lint::Active(lint) = lint {
++            if let LintData::Active(lint_data) = &lint.data {
+                 lints
+-                    .entry(lint.file)
++                    .entry(lint.name_sp.file)
+                     .or_insert_with(|| Vec::with_capacity(8))
+-                    .push((name, lint.declaration_range));
++                    .push((name, lint_data.decl_range));
+             }
+         }
+         lints
+@@ -288,7 +302,7 @@ impl<'cx> LintData<'cx> {
+ 
+     pub fn iter_passes_by_file_mut<'s>(&'s mut self) -> impl Iterator<Item = &'s mut [LintPass<'cx>]> {
+         slice_groups_mut(&mut self.lint_passes, |head, tail| {
+-            tail.iter().take_while(|&x| x.file == head.file).count()
++            tail.iter().take_while(|&x| x.decl_sp.file == head.decl_sp.file).count()
+         })
+     }
+ }
+@@ -296,8 +310,8 @@ impl<'cx> LintData<'cx> {
+ impl<'cx> ParseCxImpl<'cx> {
+     /// Finds and parses all lint declarations.
+     #[must_use]
+-    pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
+-        let mut data = LintData {
++    pub fn parse_lint_decls(&mut self) -> ParsedLints<'cx> {
++        let mut data = ParsedLints {
+             #[expect(clippy::default_trait_access)]
+             lints: FxHashMap::with_capacity_and_hasher(1000, Default::default()),
+             lint_passes: Vec::with_capacity(400),
+@@ -348,7 +362,7 @@ impl<'cx> ParseCxImpl<'cx> {
+     }
+ 
+     /// Parse a source file looking for `declare_clippy_lint` macro invocations.
+-    fn parse_lint_src_file(&mut self, data: &mut LintData<'cx>, file: &'cx SourceFile<'cx>) {
++    fn parse_lint_src_file(&mut self, data: &mut ParsedLints<'cx>, file: &'cx SourceFile<'cx>) {
+         #[allow(clippy::enum_glob_use)]
+         use cursor::Pat::*;
+         #[rustfmt::skip]
+@@ -374,11 +388,13 @@ impl<'cx> ParseCxImpl<'cx> {
+                         data.lints
+                             .insert(
+                                 self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[0])),
+-                                Lint::Active(ActiveLint {
+-                                    file,
+-                                    group: cursor.get_text(captures[1]),
+-                                    declaration_range: mac_name.pos..cursor.pos(),
+-                                }),
++                                Lint {
++                                    name_sp: captures[0].mk_sp(file),
++                                    data: LintData::Active(ActiveLint {
++                                        group: cursor.get_text(captures[1]),
++                                        decl_range: mac_name.pos..cursor.pos(),
++                                    }),
++                                },
+                             )
+                             .is_none()
+                     );
+@@ -426,8 +442,7 @@ impl<'cx> ParseCxImpl<'cx> {
+                             name,
+                             lt,
+                             mac,
+-                            file,
+-                            decl_range: mac_name.pos..cursor.pos(),
++                            decl_sp: Span::new(file, mac_name.pos..cursor.pos()),
+                             lints,
+                         });
+                     }
+@@ -437,7 +452,7 @@ impl<'cx> ParseCxImpl<'cx> {
+         }
+     }
+ 
+-    fn parse_deprecated_lints(&mut self, data: &mut LintData<'cx>) {
++    fn parse_deprecated_lints(&mut self, data: &mut ParsedLints<'cx>) {
+         #[allow(clippy::enum_glob_use)]
+         use cursor::Pat::*;
+ 
+@@ -478,10 +493,13 @@ impl<'cx> ParseCxImpl<'cx> {
+                     data.lints
+                         .insert(
+                             self.parse_clippy_lint_name(file, cursor.get_text(captures[1])),
+-                            Lint::Deprecated(DeprecatedLint {
+-                                reason: self.parse_str_single_line(file, cursor.get_text(captures[2])),
+-                                version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
+-                            }),
++                            Lint {
++                                name_sp: captures[1].mk_sp(file),
++                                data: LintData::Deprecated(DeprecatedLint {
++                                    reason: self.parse_str_single_line(file, cursor.get_text(captures[2])),
++                                    version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
++                                }),
++                            },
+                         )
+                         .is_none()
+                 );
+@@ -496,10 +514,13 @@ impl<'cx> ParseCxImpl<'cx> {
+                     data.lints
+                         .insert(
+                             self.parse_clippy_lint_name(file, cursor.get_text(captures[1])),
+-                            Lint::Renamed(RenamedLint {
+-                                new_name: self.parse_lint_name(file, cursor.get_text(captures[2])),
+-                                version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
+-                            }),
++                            Lint {
++                                name_sp: captures[1].mk_sp(file),
++                                data: LintData::Renamed(RenamedLint {
++                                    new_name: self.parse_lint_name(file, cursor.get_text(captures[2])),
++                                    version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
++                                }),
++                            },
+                         )
+                         .is_none()
+                 );
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index 5ce595d0ec1bae3ef37c8ad27c755acef0690185..76cbb070883e2800190184e12c30e522859e76b6 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -1,4 +1,4 @@
+-use super::StrBuf;
++use super::{SourceFile, Span, StrBuf};
+ use core::{ptr, slice};
+ use rustc_arena::DroplessArena;
+ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+@@ -73,6 +73,13 @@ pub struct Capture {
+ }
+ impl Capture {
+     pub const EMPTY: Self = Self { pos: 0, len: 0 };
++
++    pub fn mk_sp<'cx>(self, file: &'cx SourceFile<'cx>) -> Span<'cx> {
++        Span {
++            file,
++            range: self.pos..self.pos + self.len,
++        }
++    }
+ }
+ 
+ /// A unidirectional cursor over a token stream that is lexed on demand.

patches/20261028T105419Z/rust-lang--rust-part011/4bd9ab9e3c0feabc345454a07ecec1f5178d9740.patch

@@ -0,0 +1,110 @@
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index 6010da42c19bb90964f21d3f99d4be9556d0c868..609b12e4f1f0ea0e3b8bc43fb57f12c05cf71056 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -399,27 +399,13 @@ impl<'cx> ParseCxImpl<'cx> {
+                     let lt = if lt.is_empty() { None } else { Some(lt) };
+ 
+                     let lints = self.str_list_buf.with(|buf| {
+-                        // Parses a comma separated list of paths and converts each path
+-                        // to a string with whitespace removed.
+-                        while !cursor.eat_close_bracket() {
+-                            buf.push(self.str_buf.with(|buf| {
+-                                if cursor.eat_double_colon() {
+-                                    buf.push_str("::");
+-                                }
+-                                let capture = cursor.capture_ident()?;
+-                                buf.push_str(cursor.get_text(capture));
+-                                while cursor.eat_double_colon() {
+-                                    buf.push_str("::");
+-                                    let capture = cursor.capture_ident()?;
+-                                    buf.push_str(cursor.get_text(capture));
+-                                }
+-                                Some(self.arena.alloc_str(buf))
+-                            })?);
+-
++                        loop {
++                            match cursor.capture_opt_path(&mut self.str_buf, self.arena) {
++                                Ok(None) => break,
++                                Ok(Some(p)) => buf.push(p),
++                                Err(()) => panic!("error parsing path"),
++                            }
+                             if !cursor.eat_comma() {
+-                                if !cursor.eat_close_bracket() {
+-                                    return None;
+-                                }
+                                 break;
+                             }
+                         }
+@@ -433,7 +419,7 @@ impl<'cx> ParseCxImpl<'cx> {
+                     });
+ 
+                     if let Some(lints) = lints
+-                        && cursor.match_all(&[CloseParen, Semi], &mut [])
++                        && cursor.match_all(&[CloseBracket, CloseParen, Semi], &mut [])
+                     {
+                         data.lint_passes.push(LintPass {
+                             docs,
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index 2fffaa201582a192b55ffe8e833cf348a254f99c..5ce595d0ec1bae3ef37c8ad27c755acef0690185 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -1,4 +1,6 @@
++use super::StrBuf;
+ use core::{ptr, slice};
++use rustc_arena::DroplessArena;
+ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+ 
+ /// A token pattern used for searching and matching by the [`Cursor`].
+@@ -267,6 +269,51 @@ impl<'txt> Cursor<'txt> {
+         }
+     }
+ 
++    /// Consumes and captures the text of a path without any internal whitespace. Returns
++    /// `Err` if the path ends with `::`, and `None` if no path component exists at the
++    /// current position.
++    ///
++    /// Only paths containing identifiers separated by `::` with a possible leading `::`.
++    /// Generic arguments and qualified paths are not considered.
++    pub fn capture_opt_path(&mut self, buf: &mut StrBuf, arena: &'txt DroplessArena) -> Result<Option<&'txt str>, ()> {
++        #[derive(Clone, Copy)]
++        enum State {
++            Start,
++            Sep,
++            Ident,
++        }
++
++        buf.with(|buf| {
++            let start = self.pos;
++            let mut state = State::Start;
++            loop {
++                match (state, self.next_token.kind) {
++                    (_, TokenKind::Whitespace) => self.step(),
++                    (State::Start | State::Ident, TokenKind::Colon) if self.inner.first() == ':' => {
++                        state = State::Sep;
++                        buf.push_str("::");
++                        self.step();
++                        self.step();
++                    },
++                    (State::Start | State::Sep, TokenKind::Ident) => {
++                        state = State::Ident;
++                        buf.push_str(self.peek_text());
++                        self.step();
++                    },
++                    (State::Ident, _) => break,
++                    (State::Start, _) => return Ok(None),
++                    (State::Sep, _) => return Err(()),
++                }
++            }
++            let text = self.text[start as usize..self.pos as usize].trim();
++            Ok(Some(if text.len() == buf.len() {
++                text
++            } else {
++                arena.alloc_str(buf)
++            }))
++        })
++    }
++
+     /// Attempts to match a sequence of patterns at the current position. Returns whether
+     /// all patterns were successfully matched.
+     ///

patches/20261028T105419Z/rust-lang--rust-part011/4f5002db4e071f169e670097913a63f16f305492.patch

@@ -0,0 +1,185 @@
+diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
+index ea045ac6465f308dfe222b1803ad26d9610ab8b9..b196ae1e5a82edb2552c84e4529bc44ba6d5b1d7 100644
+--- a/compiler/rustc_passes/src/check_attr.rs
++++ b/compiler/rustc_passes/src/check_attr.rs
+@@ -1216,6 +1216,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
+         let mut is_align = false;
+         let mut is_packed = false;
+         let mut repeated_repr = false;
++        let mut maybe_last_int_type = None;
+ 
+         for (repr, _repr_span) in reprs {
+             match repr {
+@@ -1254,7 +1255,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
+                     // when checking for any other attribute together with transparent.
+                     is_transparent = true;
+                 }
+-                ReprAttr::ReprInt(_) => {
++                ReprAttr::ReprInt(int_type) => {
++                    if let Some(last_int_type) = maybe_last_int_type
++                        && last_int_type == int_type
++                    {
++                        // We'll "miss" detecting repeated int reprs if the user specifies
++                        // #[repr(u8, u64, u8)] for example. But that's okay because we've got
++                        // conflicting reprs anyway so it's not worth the effort to do more precise
++                        // tracking.
++                        repeated_repr = true;
++                    }
++                    maybe_last_int_type = Some(int_type);
+                     int_reprs += 1;
+                 }
+             };
+diff --git a/tests/ui/repr/repr-repeated-attrs.rs b/tests/ui/repr/repr-repeated-attrs.rs
+index a6dd3fb6e8b15776c7e8862666cd614b38b2b6e8..61e3ba05625d8dad51b0856ef0d66890e23026bb 100644
+--- a/tests/ui/repr/repr-repeated-attrs.rs
++++ b/tests/ui/repr/repr-repeated-attrs.rs
+@@ -19,7 +19,7 @@ struct SeveralRustReprs(u8);
+ #[repr(C, C, C)]
+ struct SeveralC(u8);
+ 
+-#[repr(u8, u8)]
++#[repr(u8, u8)] //~ WARN representation attribute is specified more than once
+ //~^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+ enum SeveralPrimitiveRerprs {
+@@ -34,7 +34,7 @@ enum SeveralCAndPrims {
+     Variant(u8),
+ }
+ 
+-#[repr(Rust, u8, u8)]
++#[repr(Rust, u8, u8)] //~ WARN representation attribute is specified more than once
+ //~^ ERROR conflicting representation hints
+ //~^^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+@@ -42,8 +42,9 @@ enum RustAndPrimDisallowed {
+     Variant(u8),
+ }
+ 
+-#[repr(u8, u8)] //~ ERROR conflicting representation hints
+-//~^ WARN this was previously accepted
++#[repr(u8, u8)] //~ WARN representation attribute is specified more than once
++//~^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
+ #[repr(u16)]
+ enum ConflictingPrimReprs {
+     Variant,
+diff --git a/tests/ui/repr/repr-repeated-attrs.stderr b/tests/ui/repr/repr-repeated-attrs.stderr
+index 72c312a13ea11adf3b3d21f1898c7299be0cf66a..57af8ec804d76d672cb87f068efef3c13ec7f68a 100644
+--- a/tests/ui/repr/repr-repeated-attrs.stderr
++++ b/tests/ui/repr/repr-repeated-attrs.stderr
+@@ -46,6 +46,14 @@ LL | #[repr(u8, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+    = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
+ 
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:22:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++   |
++   = note: for consistency, only specify the representation once
++
+ error[E0566]: conflicting representation hints
+   --> $DIR/repr-repeated-attrs.rs:29:8
+    |
+@@ -84,20 +92,39 @@ LL | #[repr(Rust, u8, u8)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:37:8
++   |
++LL | #[repr(Rust, u8, u8)]
++   |        ^^^^  ^^  ^^
++   |
++   = note: for consistency, only specify the representation once
++
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:44:8
++  --> $DIR/repr-repeated-attrs.rs:45:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+-LL |
++...
+ LL | #[repr(u16)]
+    |        ^^^
+    |
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:45:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++...
++LL | #[repr(u16)]
++   |        ^^^
++   |
++   = note: for consistency, only specify the representation once
++
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:51:8
++  --> $DIR/repr-repeated-attrs.rs:53:8
+    |
+ LL | #[repr(C, u8)]
+    |        ^  ^^
+@@ -106,7 +133,7 @@ LL | #[repr(C, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:59:8
++  --> $DIR/repr-repeated-attrs.rs:61:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+@@ -115,14 +142,14 @@ LL | #[repr(C, C, u8, u8, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ warning: representation attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:59:8
++  --> $DIR/repr-repeated-attrs.rs:61:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+    |
+    = note: for consistency, only specify the representation once
+ 
+-error: aborting due to 9 previous errors; 4 warnings emitted
++error: aborting due to 9 previous errors; 7 warnings emitted
+ 
+ Some errors have detailed explanations: E0566, E0692.
+ For more information about an error, try `rustc --explain E0566`.
+@@ -164,11 +191,11 @@ LL | #[repr(Rust, u8, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:44:8
++  --> $DIR/repr-repeated-attrs.rs:45:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+-LL |
++...
+ LL | #[repr(u16)]
+    |        ^^^
+    |
+@@ -178,7 +205,7 @@ LL | #[repr(u16)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:51:8
++  --> $DIR/repr-repeated-attrs.rs:53:8
+    |
+ LL | #[repr(C, u8)]
+    |        ^  ^^
+@@ -189,7 +216,7 @@ LL | #[repr(C, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:59:8
++  --> $DIR/repr-repeated-attrs.rs:61:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^

patches/20261028T105419Z/rust-lang--rust-part011/5110c2445166de9b493483b52e374dbea2730afa.patch

@@ -0,0 +1,33 @@
+diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
+index ba5119ee228adb60dc339aea738517db66585dd3..7cfb93ca1b86d05393395b98aef7b825fefd844f 100644
+--- a/compiler/rustc_abi/src/lib.rs
++++ b/compiler/rustc_abi/src/lib.rs
+@@ -184,6 +184,14 @@ impl ReprOptions {
+         self.flags.contains(ReprFlags::IS_C)
+     }
+ 
++    /// Returns whether this is (implicitly or explicitly) `repr(Rust)`, i.e., its layout
++    /// is defined by Rust and we make no stable commitments.
++    #[inline]
++    pub fn rust(&self) -> bool {
++        // `linear` is currently just an internal flag we set on Box; that's still `repr(Rust)`.
++        !self.c() & !self.simd() & !self.scalable() & !self.transparent()
++    }
++
+     #[inline]
+     pub fn packed(&self) -> bool {
+         self.pack.is_some()
+diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
+index c378a70da4b2b7ed6f425ad524ab703b16f51921..d10b844bf3500b5bac7b2d3aa4c69eb955fda0b1 100644
+--- a/compiler/rustc_const_eval/src/interpret/call.rs
++++ b/compiler/rustc_const_eval/src/interpret/call.rs
+@@ -97,7 +97,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
+                 } else if adt_def.repr().c() {
+                     interp_ok(false)
+                 } else {
+-                    // Must be repr(Rust).
++                    // Can't be SIMD or Scalable (since this is a 1-ZST); only Rust is left.
++                    assert!(adt_def.repr().rust());
+                     interp_ok(true)
+                 }
+             }

patches/20261028T105419Z/rust-lang--rust-part011/530a4e554f21c8283db98277baea0761be84dd66.patch

@@ -0,0 +1,12 @@
+diff --git a/src/visitor.rs b/src/visitor.rs
+index 55f9a4d8c8b26f18ed8844cf3e50e292bb6b9bbc..b3ba0f2df2cdb214ea7ab873838e8d6d53ab9c52 100644
+--- a/src/visitor.rs
++++ b/src/visitor.rs
+@@ -631,6 +631,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
+                     // For now, leave the contents of the Span unformatted.
+                     self.push_rewrite(item.span, None)
+                 }
++                ast::ItemKind::TestBinderConstraints(..) => self.push_rewrite(item.span, None),
+             };
+         }
+         self.skip_context = skip_context_saved;

patches/20261028T105419Z/rust-lang--rust-part011/536ac287713d9be8d8e8155cae8d4578e1704bf4.patch

@@ -0,0 +1,1190 @@
+diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
+index c4e06d8d6c4b99fe3cb1898b3854fa71fe243d6e..2b41201e5afb042f12053a4dd59f470c31ee5589 100644
+--- a/clippy_dev/Cargo.toml
++++ b/clippy_dev/Cargo.toml
+@@ -5,10 +5,13 @@ version = "0.0.1"
+ edition = "2024"
+ 
+ [dependencies]
++annotate-snippets = { version = "0.12.10", features = ["simd"] }
++anstream = "0.6.20"
+ chrono = { version = "0.4.38", default-features = false, features = ["clock"] }
+ clap = { version = "4.4", features = ["derive"] }
+ indoc = "1.0"
+ itertools = "0.15"
++memchr = "2.7.6"
+ opener = "0.8"
+ rustc-literal-escaper = "0.0.8"
+ walkdir = "2.3"
+diff --git a/clippy_dev/src/diag.rs b/clippy_dev/src/diag.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..49abd7dad68abae5339be7b3499f3b7fbfa29d37
+--- /dev/null
++++ b/clippy_dev/src/diag.rs
+@@ -0,0 +1,153 @@
++use crate::Span;
++use annotate_snippets::renderer::{DEFAULT_TERM_WIDTH, Renderer};
++use annotate_snippets::{Annotation, AnnotationKind, Group, Level, Origin, Snippet};
++use core::panic::Location;
++use std::borrow::Cow;
++use std::io::Write as _;
++use std::process;
++
++pub struct DiagCx {
++    out: anstream::Stderr,
++    renderer: Renderer,
++    has_err: bool,
++}
++impl Default for DiagCx {
++    fn default() -> Self {
++        let width = termize::dimensions().map_or(DEFAULT_TERM_WIDTH, |(w, _)| w);
++        Self {
++            out: anstream::stderr(),
++            renderer: Renderer::styled().term_width(width),
++            has_err: false,
++        }
++    }
++}
++impl Drop for DiagCx {
++    fn drop(&mut self) {
++        if self.has_err {
++            self.emit_err(&[
++                Group::with_title(
++                    Level::ERROR
++                        .with_name("internal error")
++                        .primary_title("errors were found, but it was assumed none occurred"),
++                ),
++                Group::with_title(Level::NOTE.secondary_title("any produced results may be incorrect")),
++            ]);
++            process::exit(1);
++        }
++    }
++}
++impl DiagCx {
++    pub fn exit_on_err(&self) {
++        if self.has_err {
++            process::exit(1);
++        }
++    }
++
++    #[track_caller]
++    pub fn exit_assume_err(&mut self) -> ! {
++        if !self.has_err {
++            self.emit_err(&[
++                Group::with_title(
++                    Level::ERROR
++                        .with_name("internal error")
++                        .primary_title("errors were expected, but failed to occur"),
++                ),
++                mk_loc_group(),
++            ]);
++        }
++        process::exit(1);
++    }
++}
++
++fn sp_to_snip(kind: AnnotationKind, sp: Span<'_>) -> Snippet<'_, Annotation<'_>> {
++    let line_starts = sp.file.line_starts();
++    let first_line = match line_starts.binary_search(&sp.range.start) {
++        Ok(x) => x,
++        // Note: `Err(0)` isn't possible since `0` is always the first start.
++        Err(x) => x - 1,
++    };
++    let start = line_starts[first_line] as usize;
++    let last_line = match line_starts.binary_search(&sp.range.end) {
++        Ok(x) => x,
++        Err(x) => x - 1,
++    };
++    let end = line_starts
++        .get(last_line + 1)
++        .map_or(sp.file.contents.len(), |&x| x as usize);
++    Snippet::source(&sp.file.contents[start..end])
++        .line_start(first_line + 1)
++        .path(sp.file.path.get())
++        .annotation(kind.span((sp.range.start as usize - start..sp.range.end as usize - start).into()))
++}
++
++fn mk_spanned_primary<'a>(level: Level<'a>, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) -> Group<'a> {
++    level
++        .primary_title(msg.into())
++        .element(sp_to_snip(AnnotationKind::Primary, sp))
++}
++
++fn mk_spanned_secondary<'a>(level: Level<'a>, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) -> Group<'a> {
++    level
++        .secondary_title(msg.into())
++        .element(sp_to_snip(AnnotationKind::Context, sp))
++}
++
++#[track_caller]
++fn mk_loc_group() -> Group<'static> {
++    let loc = Location::caller();
++    Level::INFO.secondary_title("error created here").element(
++        Origin::path(loc.file())
++            .line(loc.line() as usize)
++            .char_column(loc.column() as usize),
++    )
++}
++
++impl DiagCx {
++    fn emit_err(&mut self, groups: &[Group<'_>]) {
++        let mut s = self.renderer.render(groups);
++        s.push('\n');
++        self.out.write_all(s.as_bytes()).unwrap();
++        self.has_err = true;
++    }
++
++    #[track_caller]
++    pub fn emit_spanned_err<'a>(&mut self, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) {
++        self.emit_err(&[mk_spanned_primary(Level::ERROR, sp, msg.into()), mk_loc_group()]);
++    }
++
++    #[track_caller]
++    pub fn emit_spanless_err<'a>(&mut self, msg: impl Into<Cow<'a, str>>) {
++        self.emit_err(&[
++            Group::with_title(Level::ERROR.primary_title(msg.into())),
++            mk_loc_group(),
++        ]);
++    }
++
++    #[track_caller]
++    pub fn emit_already_deprecated(&mut self, name: &str) {
++        self.emit_spanless_err(format!("lint `{name}` is already deprecated"));
++    }
++
++    #[track_caller]
++    pub fn emit_duplicate_lint(&mut self, sp: Span<'_>, first_sp: Span<'_>) {
++        self.emit_err(&[
++            mk_spanned_primary(Level::ERROR, sp, "duplicate lint name declared"),
++            mk_spanned_secondary(Level::NOTE, first_sp, "previous declaration here"),
++            mk_loc_group(),
++        ]);
++    }
++
++    #[track_caller]
++    pub fn emit_not_clippy_lint_name(&mut self, sp: Span<'_>) {
++        self.emit_err(&[
++            mk_spanned_primary(Level::ERROR, sp, "not a clippy lint name"),
++            Group::with_title(Level::HELP.secondary_title("add the `clippy::` tool prefix")),
++            mk_loc_group(),
++        ]);
++    }
++
++    #[track_caller]
++    pub fn emit_unknown_lint(&mut self, name: &str) {
++        self.emit_spanless_err(format!("unknown lint `{name}`"));
++    }
++}
+diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
+index 078e0f2c6cd867d76ef211596fbc969183a79c39..cd1ae61f88e5e55f504e7e6c6d73c701db50e42e 100644
+--- a/clippy_dev/src/edit_lints.rs
++++ b/clippy_dev/src/edit_lints.rs
+@@ -1,9 +1,10 @@
+ use crate::parse::cursor::{self, Capture, Cursor};
+ use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, ParsedLints, RenamedLint};
+ use crate::utils::{
+-    ErrAction, FileUpdater, SourceFile, Span, UpdateMode, UpdateStatus, Version, delete_dir_if_exists,
+-    delete_file_if_exists, expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
++    ErrAction, FileUpdater, UpdateMode, UpdateStatus, Version, delete_dir_if_exists, delete_file_if_exists,
++    expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
+ };
++use crate::{SourceFile, Span};
+ use core::mem;
+ use rustc_lexer::TokenKind;
+ use std::collections::hash_map::Entry;
+@@ -22,10 +23,9 @@ use std::{fs, path};
+ /// If a file path could not read from or written to
+ pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name: &'env str, reason: &'env str) {
+     let mut data = cx.parse_lint_decls();
+-
+     let Entry::Occupied(mut lint) = data.lints.entry(name) else {
+-        eprintln!("error: failed to find lint `{name}`");
+-        return;
++        cx.dcx.emit_unknown_lint(name);
++        cx.dcx.exit_assume_err();
+     };
+     let prev_lint = mem::replace(
+         lint.get_mut(),
+@@ -38,9 +38,10 @@ pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name
+         },
+     );
+     let LintData::Active(prev_lint_data) = prev_lint.data else {
+-        eprintln!("error: `{name}` is already deprecated");
+-        return;
++        cx.dcx.emit_already_deprecated(name);
++        cx.dcx.exit_assume_err();
+     };
++    cx.dcx.exit_on_err();
+ 
+     remove_lint_declaration(
+         name,
+@@ -56,14 +57,10 @@ pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name
+ 
+ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_name: &'env str, new_name: &'env str) {
+     let mut data = cx.parse_lint_decls();
+-
+-    update_rename_targets(&mut data, old_name, LintName::new_rustc(new_name));
+-
+     let Entry::Occupied(mut lint) = data.lints.entry(old_name) else {
+-        eprintln!("error: failed to find lint `{old_name}`");
+-        return;
++        cx.dcx.emit_unknown_lint(old_name);
++        cx.dcx.exit_assume_err();
+     };
+-
+     let prev_lint = mem::replace(
+         lint.get_mut(),
+         Lint {
+@@ -75,10 +72,12 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+         },
+     );
+     let LintData::Active(prev_lint_data) = prev_lint.data else {
+-        eprintln!("error: `{old_name}` is already deprecated");
+-        return;
++        cx.dcx.emit_already_deprecated(old_name);
++        cx.dcx.exit_assume_err();
+     };
++    cx.dcx.exit_on_err();
+ 
++    update_rename_targets(&mut data, old_name, LintName::new_rustc(new_name));
+     let mut updater = FileUpdater::default();
+     let remove_mod = remove_lint_declaration(old_name, prev_lint.name_sp.file, &prev_lint_data, &data, &mut updater);
+     let mut update_fn = uplift_update_fn(old_name, new_name, remove_mod);
+@@ -109,16 +108,11 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+ /// * If `old_name` doesn't name an existing lint.
+ /// * If `old_name` names a deprecated or renamed lint.
+ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_name: &'env str, new_name: &'env str) {
+-    let mut updater = FileUpdater::default();
+     let mut data = cx.parse_lint_decls();
+-
+-    update_rename_targets(&mut data, old_name, LintName::new_clippy(new_name));
+-
+     let Entry::Occupied(mut lint) = data.lints.entry(old_name) else {
+-        eprintln!("error: failed to find lint `{old_name}`");
+-        return;
++        cx.dcx.emit_unknown_lint(old_name);
++        cx.dcx.exit_assume_err();
+     };
+-
+     let prev_lint = mem::replace(
+         lint.get_mut(),
+         Lint {
+@@ -130,10 +124,12 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
+         },
+     );
+     if !matches!(prev_lint.data, LintData::Active(_)) {
+-        eprintln!("error: `{old_name}` is already deprecated");
+-        return;
+-    };
++        cx.dcx.emit_already_deprecated(old_name);
++    }
++    cx.dcx.exit_on_err();
+ 
++    update_rename_targets(&mut data, old_name, LintName::new_clippy(new_name));
++    let mut updater = FileUpdater::default();
+     let prev_file = prev_lint.name_sp.file;
+     let mut rename_mod = false;
+     if let Entry::Vacant(e) = data.lints.entry(new_name) {
+@@ -401,7 +397,9 @@ fn rename_update_fn<'a>(
+                     match text {
+                         // clippy::line_name or clippy::lint-name
+                         "clippy" => {
+-                            if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
++                            if cursor
++                                .match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
++                                .is_ok()
+                                 && cursor.get_text(captures[0]) == old_name
+                             {
+                                 dst.push_str(&src[copy_pos as usize..captures[0].pos as usize]);
+@@ -464,7 +462,9 @@ fn rename_update_fn<'a>(
+                 },
+                 // ::lint_name
+                 TokenKind::Colon
+-                    if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
++                    if cursor
++                        .match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
++                        .is_ok()
+                         && cursor.get_text(captures[0]) == old_name =>
+                 {
+                     dst.push_str(&src[copy_pos as usize..captures[0].pos as usize]);
+diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
+index b479c4d70c9580c22aabf7ba67e837eae94dcf2c..992eb049e7410f7fd62b74e1002095e73fd731c7 100644
+--- a/clippy_dev/src/fmt.rs
++++ b/clippy_dev/src/fmt.rs
+@@ -336,6 +336,7 @@ pub fn run(update_mode: UpdateMode) {
+ 
+     new_parse_cx(|cx| {
+         let mut data = cx.parse_lint_decls();
++        cx.dcx.exit_on_err();
+ 
+         let mut updater = FileUpdater::default();
+ 
+diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
+index 5c15839cd3ddf9f6687699bb8e58621b5baab3c6..0e1f985a8ef389bff3bcac2d17f7d4a7ae76bc92 100644
+--- a/clippy_dev/src/lib.rs
++++ b/clippy_dev/src/lib.rs
+@@ -21,6 +21,7 @@ extern crate rustc_data_structures;
+ #[expect(unused_extern_crates, reason = "required to link to rustc crates")]
+ extern crate rustc_driver;
+ extern crate rustc_lexer;
++extern crate termize;
+ 
+ pub mod dogfood;
+ pub mod edit_lints;
+@@ -32,9 +33,11 @@ pub mod serve;
+ pub mod setup;
+ pub mod sync;
+ 
++mod diag;
+ mod generate;
+ mod parse;
+ mod utils;
+ 
++pub use self::diag::DiagCx;
+ pub use self::parse::{ParseCx, new_parse_cx};
+-pub use self::utils::{ClippyInfo, UpdateMode};
++pub use self::utils::{ClippyInfo, SourceFile, Span, UpdateMode};
+diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
+index 5fe2295a1e21dfb50572f7d9fc989f8dce57d229..9e0f2fa14cb0ae8df8c412be9af4a56a4cf1b111 100644
+--- a/clippy_dev/src/main.rs
++++ b/clippy_dev/src/main.rs
+@@ -26,9 +26,11 @@ fn main() {
+             allow_no_vcs,
+         } => dogfood::dogfood(fix, allow_dirty, allow_staged, allow_no_vcs),
+         DevCommand::Fmt { check } => fmt::run(UpdateMode::from_check(check)),
+-        DevCommand::UpdateLints { check } => {
+-            new_parse_cx(|cx| cx.parse_lint_decls().gen_decls(UpdateMode::from_check(check)));
+-        },
++        DevCommand::UpdateLints { check } => new_parse_cx(|cx| {
++            let data = cx.parse_lint_decls();
++            cx.dcx.exit_on_err();
++            data.gen_decls(UpdateMode::from_check(check));
++        }),
+         DevCommand::NewLint {
+             pass,
+             name,
+@@ -36,7 +38,11 @@ fn main() {
+             r#type,
+             msrv,
+         } => match new_lint::create(clippy.version, pass, &name, &category, r#type.as_deref(), msrv) {
+-            Ok(()) => new_parse_cx(|cx| cx.parse_lint_decls().gen_decls(UpdateMode::Change)),
++            Ok(()) => new_parse_cx(|cx| {
++                let data = cx.parse_lint_decls();
++                cx.dcx.exit_on_err();
++                data.gen_decls(UpdateMode::Change);
++            }),
+             Err(e) => eprintln!("Unable to create lint: {e}"),
+         },
+         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
+diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
+index 78eaabbb794e877510be7210cb98078234515d65..3c797fb2247eb290ead694ecee751656543b61f3 100644
+--- a/clippy_dev/src/new_lint.rs
++++ b/clippy_dev/src/new_lint.rs
+@@ -531,10 +531,16 @@ fn parse_mod_file(path: &Path, contents: &str) -> (&'static str, usize) {
+     let mut captures = [Capture::EMPTY];
+     while let Some(name) = cursor.find_capture_ident() {
+         match cursor.get_text(name) {
+-            "declare_clippy_lint" if cursor.match_all(&[Bang, OpenBrace], &mut []) && cursor.find_close_brace() => {
++            "declare_clippy_lint"
++                if cursor.match_all(&[Bang, OpenBrace], &mut []).is_ok() && cursor.find_close_brace() =>
++            {
+                 decl_end = Some(cursor.pos());
+             },
+-            "impl" if cursor.match_all(&[Lt, Lifetime, Gt, CaptureIdent], &mut captures) => {
++            "impl"
++                if cursor
++                    .match_all(&[Lt, Lifetime, Gt, CaptureIdent], &mut captures)
++                    .is_ok() =>
++            {
+                 match cursor.get_text(captures[0]) {
+                     "LateLintPass" => context = Some("LateContext"),
+                     "EarlyLintPass" => context = Some("EarlyContext"),
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index 95fb22accc079f46fc8b1b66425340cd99ba4939..e589485dc8f4dfcb1dce2690178fef3d4ce2b3c9 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -1,13 +1,13 @@
+ pub mod cursor;
+ 
+ use self::cursor::{Capture, Cursor, IdentPat};
+-use crate::utils::{
+-    ErrAction, Scoped, SourceFile, Span, StrBuf, VecBuf, expect_action, slice_groups_mut, walk_dir_no_dot_or_target,
+-};
++use crate::utils::{ErrAction, Scoped, StrBuf, VecBuf, expect_action, slice_groups_mut, walk_dir_no_dot_or_target};
++use crate::{DiagCx, SourceFile, Span};
+ use core::fmt::{self, Display};
+ use core::range::Range;
+ use rustc_arena::{DroplessArena, TypedArena};
+ use rustc_data_structures::fx::FxHashMap;
++use std::collections::hash_map::{Entry, VacantEntry};
+ use std::{fs, path};
+ 
+ pub struct ParseCxImpl<'cx> {
+@@ -15,6 +15,7 @@ pub struct ParseCxImpl<'cx> {
+     pub source_files: &'cx TypedArena<SourceFile<'cx>>,
+     pub str_buf: StrBuf,
+     pub str_list_buf: VecBuf<&'cx str>,
++    pub dcx: DiagCx,
+ }
+ pub type ParseCx<'cx> = &'cx mut ParseCxImpl<'cx>;
+ 
+@@ -27,6 +28,7 @@ pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx, 'env,
+         source_files: &source_files,
+         str_buf: StrBuf::with_capacity(128),
+         str_list_buf: VecBuf::with_capacity(128),
++        dcx: DiagCx::default(),
+     }))
+ }
+ 
+@@ -43,25 +45,29 @@ impl LintTool {
+             Self::Clippy => "clippy::",
+         }
+     }
++
++    pub fn from_prefix(s: &str) -> Option<Self> {
++        (s == "clippy").then_some(Self::Clippy)
++    }
+ }
+ 
+ #[derive(Clone, Copy, PartialEq, Eq, Hash)]
+ pub struct LintName<'cx> {
+-    pub name: &'cx str,
+     pub tool: LintTool,
++    pub name: &'cx str,
+ }
+ impl<'cx> LintName<'cx> {
+     pub fn new_rustc(name: &'cx str) -> Self {
+         Self {
+-            name,
+             tool: LintTool::Rustc,
++            name,
+         }
+     }
+ 
+     pub fn new_clippy(name: &'cx str) -> Self {
+         Self {
+-            name,
+             tool: LintTool::Clippy,
++            name,
+         }
+     }
+ }
+@@ -149,11 +155,26 @@ impl<'cx> ParsedLints<'cx> {
+             tail.iter().take_while(|&x| x.decl_sp.file == head.decl_sp.file).count()
+         })
+     }
++
++    #[track_caller]
++    fn get_vacant_lint<'a>(
++        &'a mut self,
++        dcx: &mut DiagCx,
++        name: &'cx str,
++        name_sp: Span<'cx>,
++    ) -> Option<VacantEntry<'a, &'cx str, Lint<'cx>>> {
++        match self.lints.entry(name) {
++            Entry::Vacant(e) => Some(e),
++            Entry::Occupied(e) => {
++                dcx.emit_duplicate_lint(name_sp, e.get().name_sp);
++                None
++            },
++        }
++    }
+ }
+ 
+ impl<'cx> ParseCxImpl<'cx> {
+     /// Finds and parses all lint declarations.
+-    #[must_use]
+     pub fn parse_lint_decls(&mut self) -> ParsedLints<'cx> {
+         let mut data = ParsedLints {
+             #[expect(clippy::default_trait_access)]
+@@ -209,83 +230,87 @@ impl<'cx> ParseCxImpl<'cx> {
+     fn parse_lint_src_file(&mut self, data: &mut ParsedLints<'cx>, file: &'cx SourceFile<'cx>) {
+         #[allow(clippy::enum_glob_use)]
+         use cursor::Pat::*;
+-        #[rustfmt::skip]
+-        static LINT_DECL_TOKENS: &[cursor::Pat] = &[
+-            // !{ /// docs
+-            Bang, OpenBrace, AnyComments,
+-            // #[clippy::version = "version"]
+-            Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
+-            Ident(IdentPat::version), Eq, LitStr, CloseBracket,
+-            // pub NAME, GROUP,
+-            Ident(IdentPat::r#pub), CaptureIdent, Comma, AnyComments, CaptureIdent, Comma,
+-        ];
+ 
+         let mut cursor = Cursor::new(&file.contents);
+         let mut captures = [Capture::EMPTY; 3];
+         while let Some(mac_name) = cursor.find_capture_ident() {
+-            captures[1] = Capture::EMPTY;
++            if !cursor.eat_bang() {
++                continue;
++            }
+             match cursor.get_text(mac_name) {
+-                "declare_clippy_lint"
+-                    if cursor.match_all(LINT_DECL_TOKENS, &mut captures) && cursor.find_close_brace() =>
+-                {
+-                    assert!(
+-                        data.lints
+-                            .insert(
+-                                self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[0])),
+-                                Lint {
+-                                    name_sp: captures[0].mk_sp(file),
+-                                    data: LintData::Active(ActiveLint {
+-                                        group: cursor.get_text(captures[1]),
+-                                        decl_range: mac_name.pos..cursor.pos(),
+-                                    }),
+-                                },
+-                            )
+-                            .is_none()
+-                    );
++                "declare_clippy_lint" => {
++                    #[rustfmt::skip]
++                    static DECL_START: &[cursor::Pat] = &[
++                        // { /// docs
++                        OpenBrace, AnyComments,
++                        // #[clippy::version = "version"]
++                        Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
++                        Ident(IdentPat::version), Eq, CaptureLitStr, CloseBracket,
++                        // pub NAME, GROUP, "desc",
++                        Ident(IdentPat::r#pub), CaptureIdent, Comma,
++                        AnyComments, CaptureIdent, Comma, AnyComments, LitStr,
++                    ];
++                    #[rustfmt::skip]
++                    static OPTION: &[cursor::Pat] = &[
++                        // @option = value
++                        AnyComments, At, AnyIdent, Eq, Lit,
++                    ];
++
++                    if let Err(expected) = cursor
++                        .match_all(DECL_START, &mut captures)
++                        .and_then(|()| {
++                            (!cursor.eat_comma()).ok_or(()).or_else(|()| {
++                                cursor.eat_list(|cursor| cursor.match_all(OPTION, &mut []).map(|()| true))
++                            })
++                        })
++                        .and_then(|()| cursor.eat_close_brace().ok_or("`}`"))
++                    {
++                        cursor.emit_unexpected(&mut self.dcx, file, expected);
++                    } else if let name = self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[1]))
++                        && let name_sp = captures[1].mk_sp(file)
++                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
++                    {
++                        let _ = self.parse_version(cursor.get_text(captures[0]), captures[0].mk_sp(file));
++                        e.insert(Lint {
++                            name_sp,
++                            data: LintData::Active(ActiveLint {
++                                group: cursor.get_text(captures[2]),
++                                decl_range: mac_name.pos..cursor.pos(),
++                            }),
++                        });
++                    }
+                 },
+-                mac @ ("declare_lint_pass" | "impl_lint_pass")
+-                    if cursor.match_all(&[Bang, OpenParen, CaptureDocLines, CaptureIdent], &mut captures)
+-                        && cursor.opt_match_all(&[Lt, CaptureLifetime, Gt], &mut captures[2..])
+-                        && cursor.match_all(&[FatArrow, OpenBracket], &mut captures) =>
+-                {
+-                    let mac = if matches!(mac, "declare_lint_pass") {
+-                        LintPassMac::Declare
+-                    } else {
+-                        LintPassMac::Impl
+-                    };
+-                    let docs = cursor.get_text(captures[0]);
+-                    let name = cursor.get_text(captures[1]);
+-                    let lt = cursor.get_text(captures[2]);
+-                    let lt = if lt.is_empty() { None } else { Some(lt) };
+-
+-                    let lints = self.str_list_buf.with(|buf| {
+-                        loop {
+-                            match cursor.capture_opt_path(&mut self.str_buf, self.arena) {
+-                                Ok(None) => break,
+-                                Ok(Some(p)) => buf.push(p),
+-                                Err(()) => panic!("error parsing path"),
+-                            }
+-                            if !cursor.eat_comma() {
+-                                break;
+-                            }
+-                        }
+-
+-                        // The arena panics when allocating a size of zero.
+-                        Some(if buf.is_empty() {
+-                            &mut []
+-                        } else {
+-                            self.arena.alloc_slice(buf)
++                mac @ ("declare_lint_pass" | "impl_lint_pass") => {
++                    let mut has_lt = false;
++                    let mut lints: &mut [_] = &mut [];
++                    if let Err(expected) = cursor
++                        .match_all(&[OpenParen, CaptureDocLines, CaptureIdent], &mut captures)
++                        .and_then(|()| cursor.opt_match_all(&[Lt, CaptureLifetime, Gt], &mut captures[2..]))
++                        .and_then(|res| {
++                            has_lt = res;
++                            cursor.match_all(&[FatArrow, OpenBracket], &mut [])
++                        })
++                        .and_then(|()| {
++                            cursor.capture_list(&mut self.str_list_buf, self.arena, |cursor| {
++                                cursor.capture_opt_path(&mut self.str_buf, self.arena)
++                            })
++                        })
++                        .and_then(|res| {
++                            lints = res;
++                            cursor.match_all(&[CloseBracket, CloseParen, Semi], &mut [])
+                         })
+-                    });
+-
+-                    if let Some(lints) = lints
+-                        && cursor.match_all(&[CloseBracket, CloseParen, Semi], &mut [])
+                     {
++                        cursor.emit_unexpected(&mut self.dcx, file, expected);
++                    } else {
+                         data.lint_passes.push(LintPass {
+-                            docs,
+-                            name,
+-                            lt,
+-                            mac,
++                            docs: cursor.get_text(captures[0]),
++                            name: cursor.get_text(captures[1]),
++                            lt: has_lt.then(|| cursor.get_text(captures[2])),
++                            mac: if matches!(mac, "declare_lint_pass") {
++                                LintPassMac::Declare
++                            } else {
++                                LintPassMac::Impl
++                            },
+                             decl_sp: Span::new(file, mac_name.pos..cursor.pos()),
+                             lints,
+                         });
+@@ -305,8 +330,8 @@ impl<'cx> ParseCxImpl<'cx> {
+             // #[clippy::version = "version"]
+             Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
+             Ident(IdentPat::version), Eq, CaptureLitStr, CloseBracket,
+-            // ("first", "second"),
+-            OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen, Comma,
++            // ("first", "second")
++            OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen,
+         ];
+         #[rustfmt::skip]
+         static DEPRECATED_TOKENS: &[cursor::Pat] = &[
+@@ -325,113 +350,163 @@ impl<'cx> ParseCxImpl<'cx> {
+         let mut cursor = Cursor::new(&file.contents);
+         let mut captures = [Capture::EMPTY; 3];
+ 
+-        // First instance is the macro definition.
+-        assert!(
+-            cursor.find_ident("declare_with_version"),
+-            "error reading deprecated lints"
+-        );
+-
+-        if cursor.find_ident("declare_with_version") && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
+-            while cursor.match_all(DECL_TOKENS, &mut captures) {
+-                assert!(
+-                    data.lints
+-                        .insert(
+-                            self.parse_clippy_lint_name(file, cursor.get_text(captures[1])),
+-                            Lint {
+-                                name_sp: captures[1].mk_sp(file),
+-                                data: LintData::Deprecated(DeprecatedLint {
+-                                    reason: self.parse_str_single_line(file, cursor.get_text(captures[2])),
+-                                    version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
+-                                }),
+-                            },
++        if let Err(expected) = cursor
++            .find_ident("declare_with_version")
++            .ok_or("`declare_with_version`")
++            .and_then(|()| {
++                cursor
++                    .find_ident("declare_with_version")
++                    .ok_or("`declare_with_version`")
++            })
++            .and_then(|()| cursor.match_all(DEPRECATED_TOKENS, &mut []))
++            .and_then(|()| {
++                cursor.eat_list(|cursor| {
++                    let parsed = cursor.opt_match_all(DECL_TOKENS, &mut captures)?;
++                    if parsed
++                        && let [version, name, reason] = captures
++                        && let name_sp = name.mk_sp(file)
++                        && let (Some(version), Some(name), Some(reason)) = (
++                            self.parse_version(cursor.get_text(version), version.mk_sp(file)),
++                            self.parse_clippy_lint_name(cursor.get_text(name), name_sp),
++                            self.parse_str_lit(cursor.get_text(reason), reason.mk_sp(file)),
+                         )
+-                        .is_none()
+-                );
+-            }
+-        } else {
+-            panic!("error reading deprecated lints");
+-        }
+-
+-        if cursor.find_ident("declare_with_version") && cursor.match_all(RENAMED_TOKENS, &mut []) {
+-            while cursor.match_all(DECL_TOKENS, &mut captures) {
+-                assert!(
+-                    data.lints
+-                        .insert(
+-                            self.parse_clippy_lint_name(file, cursor.get_text(captures[1])),
+-                            Lint {
+-                                name_sp: captures[1].mk_sp(file),
+-                                data: LintData::Renamed(RenamedLint {
+-                                    new_name: self.parse_lint_name(file, cursor.get_text(captures[2])),
+-                                    version: self.parse_str_single_line(file, cursor.get_text(captures[0])),
+-                                }),
+-                            },
++                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
++                    {
++                        e.insert(Lint {
++                            name_sp,
++                            data: LintData::Deprecated(DeprecatedLint { reason, version }),
++                        });
++                    }
++                    Ok(parsed)
++                })
++            })
++            .and_then(|()| {
++                cursor
++                    .find_ident("declare_with_version")
++                    .ok_or("`declare_with_version`")
++            })
++            .and_then(|()| cursor.match_all(RENAMED_TOKENS, &mut []))
++            .and_then(|()| {
++                cursor.eat_list(|cursor| {
++                    let parsed = cursor.opt_match_all(DECL_TOKENS, &mut captures)?;
++                    if parsed
++                        && let [version, name, new_name] = captures
++                        && let name_sp = name.mk_sp(file)
++                        && let (Some(version), Some(name), Some(new_name)) = (
++                            self.parse_version(cursor.get_text(version), version.mk_sp(file)),
++                            self.parse_clippy_lint_name(cursor.get_text(name), name_sp),
++                            self.parse_lint_name(cursor.get_text(new_name), new_name.mk_sp(file)),
+                         )
+-                        .is_none()
+-                );
+-            }
+-        } else {
+-            panic!("error reading renamed lints");
++                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
++                    {
++                        e.insert(Lint {
++                            name_sp,
++                            data: LintData::Renamed(RenamedLint { new_name, version }),
++                        });
++                    }
++                    Ok(parsed)
++                })
++            })
++        {
++            cursor.emit_unexpected(&mut self.dcx, file, expected);
+         }
+     }
+ 
+-    /// Removes the line splices and surrounding quotes from a string literal
+-    fn parse_str_lit(&mut self, s: &'cx str) -> &'cx str {
+-        let (s, is_raw) = if let Some(s) = s.strip_prefix("r") {
+-            (s.trim_matches('#'), true)
++    /// Removes the line splices and surrounding quotes from a string literal.
++    fn parse_str_lit(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
++        let (s, is_raw, sp_base) = if let Some(trimmed) = s.strip_prefix("r") {
++            let trimmed = trimmed.trim_start_matches('#');
++            #[expect(clippy::cast_possible_truncation)]
++            let sp_base = (s.len() - trimmed.len() + 1) as u32;
++            (trimmed.trim_end_matches('#'), true, sp_base)
+         } else {
+-            (s, false)
++            (s, false, 1)
+         };
++        let sp_base = sp.range.start + sp_base;
+         let s = s
+             .strip_prefix('"')
+             .and_then(|s| s.strip_suffix('"'))
+             .unwrap_or_else(|| panic!("expected quoted string, found `{s}`"));
+ 
++        let mut is_ok = true;
+         if is_raw {
+-            s
++            rustc_literal_escaper::check_raw_str(s, |range, c| {
++                if c.is_err_and(|e| e.is_fatal()) {
++                    #[expect(clippy::cast_possible_truncation)]
++                    let range = range.start as u32 + sp_base..range.end as u32 + sp_base;
++                    self.dcx
++                        .emit_spanned_err(Span::new(sp.file, range), "invalid string escape sequence");
++                    is_ok = false;
++                }
++            });
++            is_ok.then_some(s)
+         } else {
+             self.str_buf.with(|buf| {
+-                rustc_literal_escaper::unescape_str(s, &mut |_, ch| {
+-                    if let Ok(ch) = ch {
+-                        buf.push(ch);
+-                    }
++                rustc_literal_escaper::unescape_str(s, |range, c| match c {
++                    Ok(c) => buf.push(c),
++                    Err(e) if e.is_fatal() => {
++                        #[expect(clippy::cast_possible_truncation)]
++                        let range = range.start as u32 + sp_base..range.end as u32 + sp_base;
++                        self.dcx
++                            .emit_spanned_err(Span::new(sp.file, range), "invalid string escape sequence");
++                        is_ok = false;
++                    },
++                    Err(_) => {},
+                 });
+-                if buf == s {
+-                    s
+-                } else if buf.is_empty() {
+-                    ""
+-                } else {
+-                    self.arena.alloc_str(buf)
+-                }
++                is_ok.then(|| {
++                    if buf == s {
++                        s
++                    } else if buf.is_empty() {
++                        ""
++                    } else {
++                        self.arena.alloc_str(buf)
++                    }
++                })
+             })
+         }
+     }
+ 
+-    fn parse_str_single_line(&mut self, file: &SourceFile<'_>, s: &'cx str) -> &'cx str {
+-        let value = self.parse_str_lit(s);
+-        assert!(
+-            !value.contains('\n'),
+-            "error parsing `{}`: `{s}` should be a single line string",
+-            file.path.get(),
+-        );
+-        value
++    #[track_caller]
++    fn parse_lint_name(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<LintName<'cx>> {
++        let s = self.parse_str_lit(s, sp)?;
++        let (tool, name) = match s.split_once("::") {
++            Some((tool, name)) if let Some(tool) = LintTool::from_prefix(tool) => (tool, name),
++            Some(..) => {
++                self.dcx.emit_spanned_err(sp, "unknown lint tool");
++                return None;
++            },
++            None => (LintTool::Rustc, s),
++        };
++        if name
++            .bytes()
++            .all(|c| matches!(c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_'))
++        {
++            Some(LintName { tool, name })
++        } else {
++            self.dcx.emit_spanned_err(sp, "unparsable lint name");
++            None
++        }
+     }
+ 
+-    fn parse_clippy_lint_name(&mut self, file: &SourceFile<'_>, s: &'cx str) -> &'cx str {
+-        match self.parse_str_single_line(file, s).strip_prefix("clippy::") {
+-            Some(x) => x,
+-            None => panic!(
+-                "error parsing `{}`: `{s}` should be a string starting with `clippy::`",
+-                file.path.get(),
+-            ),
++    #[track_caller]
++    fn parse_clippy_lint_name(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
++        let name = self.parse_lint_name(s, sp)?;
++        if name.tool == LintTool::Clippy {
++            Some(name.name)
++        } else {
++            self.dcx.emit_not_clippy_lint_name(sp);
++            None
+         }
+     }
+ 
+-    fn parse_lint_name(&mut self, file: &SourceFile<'_>, s: &'cx str) -> LintName<'cx> {
+-        let s = self.parse_str_single_line(file, s);
+-        let (name, tool) = match s.strip_prefix("clippy::") {
+-            Some(s) => (s, LintTool::Clippy),
+-            None => (s, LintTool::Rustc),
+-        };
+-        LintName { name, tool }
++    #[track_caller]
++    fn parse_version(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
++        let s = self.parse_str_lit(s, sp)?;
++        if s.bytes().all(|c| matches!(c, b'0'..=b'9' | b'.')) || matches!(s, "pre 1.29.0" | "CURRENT_RUSTC_VERSION") {
++            Some(s)
++        } else {
++            self.dcx.emit_spanned_err(sp, "unparsable version number");
++            None
++        }
+     }
+ }
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index 76cbb070883e2800190184e12c30e522859e76b6..2ee007615a67e5820e5153dcc6c12e46626652cf 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -1,4 +1,5 @@
+-use super::{SourceFile, Span, StrBuf};
++use crate::utils::{StrBuf, VecBuf};
++use crate::{DiagCx, SourceFile, Span};
+ use core::{ptr, slice};
+ use rustc_arena::DroplessArena;
+ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+@@ -17,6 +18,8 @@ pub enum Pat {
+     CaptureIdent,
+     CaptureLifetime,
+     CaptureLitStr,
++    AnyIdent,
++    At,
+     Bang,
+     CloseBracket,
+     CloseParen,
+@@ -27,6 +30,7 @@ pub enum Pat {
+     Gt,
+     Ident(IdentPat),
+     Lifetime,
++    Lit,
+     LitStr,
+     Lt,
+     OpenBrace,
+@@ -35,6 +39,34 @@ pub enum Pat {
+     Pound,
+     Semi,
+ }
++impl Pat {
++    pub fn desc(self) -> &'static str {
++        match self {
++            Self::AnyComments => "comments",
++            Self::CaptureDocLines => "doc line comments",
++            Self::AnyIdent | Self::CaptureIdent => "an identifier",
++            Self::At => "`@`",
++            Self::Bang => "`!`",
++            Self::CloseBracket => "`]`",
++            Self::CloseParen => "`)`",
++            Self::Comma => "`,`",
++            Self::DoubleColon => "`::`",
++            Self::Eq => "`=`",
++            Self::FatArrow => "`=>`",
++            Self::Gt => "`>`",
++            Self::Ident(x) => x.desc(),
++            Self::Lifetime | Self::CaptureLifetime => "a lifetime",
++            Self::Lit => "a literal",
++            Self::LitStr | Self::CaptureLitStr => "a string literal",
++            Self::Lt => "`<`",
++            Self::OpenBrace => "`{`",
++            Self::OpenBracket => "`[`",
++            Self::OpenParen => "`(`",
++            Self::Pound => "`#`",
++            Self::Semi => "`;`",
++        }
++    }
++}
+ 
+ macro_rules! ident_or_lit {
+     ($ident:ident) => {
+@@ -53,6 +85,10 @@ macro_rules! decl_ident_pats {
+             pub fn as_str(self) -> &'static str {
+                 match self { $(Self::$ident => ident_or_lit!($ident $($s)?)),* }
+             }
++
++            pub fn desc(self) -> &'static str {
++                match self { $(Self::$ident => concat!("`", ident_or_lit!($ident $($s)?), "`")),* }
++            }
+         }
+     }
+ }
+@@ -142,6 +178,17 @@ impl<'txt> Cursor<'txt> {
+         self.next_token = self.inner.advance_token();
+     }
+ 
++    #[track_caller]
++    pub fn emit_unexpected<'cx>(&self, dcx: &mut DiagCx, file: &'cx SourceFile<'cx>, expected: &'static str) {
++        let sp = Span::new(file, self.pos..self.pos + self.next_token.len);
++        let msg = if matches!(self.next_token.kind, TokenKind::Eof) {
++            "end of file"
++        } else {
++            "token"
++        };
++        dcx.emit_spanned_err(sp, format!("unexpected {msg}, expected {expected}"));
++    }
++
+     /// Consumes tokens until the given pattern is either fully matched of fails to match.
+     /// Returns whether the pattern was fully matched.
+     ///
+@@ -159,12 +206,16 @@ impl<'txt> Cursor<'txt> {
+                 (Pat::AnyComments, _) => return true,
+ 
+                 (Pat::Ident(x), TokenKind::Ident) if x.as_str() == self.peek_text() => break,
+-                (Pat::Bang, TokenKind::Bang)
++                (Pat::Lit, TokenKind::Ident) if matches!(self.peek_text(), "true" | "false") => break,
++                (Pat::At, TokenKind::At)
++                | (Pat::AnyIdent, TokenKind::Ident | TokenKind::RawIdent)
++                | (Pat::Bang, TokenKind::Bang)
+                 | (Pat::CloseBracket, TokenKind::CloseBracket)
+                 | (Pat::CloseParen, TokenKind::CloseParen)
+                 | (Pat::Comma, TokenKind::Comma)
+                 | (Pat::Eq, TokenKind::Eq)
+                 | (Pat::Lifetime, TokenKind::Lifetime { .. })
++                | (Pat::Lit, TokenKind::Literal { .. })
+                 | (Pat::Lt, TokenKind::Lt)
+                 | (Pat::Gt, TokenKind::Gt)
+                 | (Pat::OpenBrace, TokenKind::OpenBrace)
+@@ -223,11 +274,11 @@ impl<'txt> Cursor<'txt> {
+                     };
+                     return true;
+                 },
+-
+                 (Pat::CaptureDocLines, _) => {
+                     *captures.next().unwrap() = Capture::EMPTY;
+                     return true;
+                 },
++
+                 _ => return false,
+             }
+         }
+@@ -282,7 +333,11 @@ impl<'txt> Cursor<'txt> {
+     ///
+     /// Only paths containing identifiers separated by `::` with a possible leading `::`.
+     /// Generic arguments and qualified paths are not considered.
+-    pub fn capture_opt_path(&mut self, buf: &mut StrBuf, arena: &'txt DroplessArena) -> Result<Option<&'txt str>, ()> {
++    pub fn capture_opt_path(
++        &mut self,
++        buf: &mut StrBuf,
++        arena: &'txt DroplessArena,
++    ) -> Result<Option<&'txt str>, &'static str> {
+         #[derive(Clone, Copy)]
+         enum State {
+             Start,
+@@ -309,7 +364,7 @@ impl<'txt> Cursor<'txt> {
+                     },
+                     (State::Ident, _) => break,
+                     (State::Start, _) => return Ok(None),
+-                    (State::Sep, _) => return Err(()),
++                    (State::Sep, _) => return Err(Pat::AnyIdent.desc()),
+                 }
+             }
+             let text = self.text[start as usize..self.pos as usize].trim();
+@@ -321,6 +376,36 @@ impl<'txt> Cursor<'txt> {
+         })
+     }
+ 
++    pub fn eat_list(&mut self, mut f: impl FnMut(&mut Self) -> Result<bool, &'static str>) -> Result<(), &'static str> {
++        while f(self)? {
++            if !self.eat_comma() {
++                break;
++            }
++        }
++        Ok(())
++    }
++
++    pub fn capture_list<'cx, T: Copy>(
++        &mut self,
++        buf: &mut VecBuf<T>,
++        arena: &'cx DroplessArena,
++        mut f: impl FnMut(&mut Self) -> Result<Option<T>, &'static str>,
++    ) -> Result<&'cx mut [T], &'static str> {
++        buf.with(|buf| {
++            while let Some(x) = f(self)? {
++                buf.push(x);
++                if !self.eat_comma() {
++                    break;
++                }
++            }
++            Ok(if buf.is_empty() {
++                &mut []
++            } else {
++                arena.alloc_slice(buf)
++            })
++        })
++    }
++
+     /// Attempts to match a sequence of patterns at the current position. Returns whether
+     /// all patterns were successfully matched.
+     ///
+@@ -330,10 +415,10 @@ impl<'txt> Cursor<'txt> {
+     /// unmodified.
+     ///
+     /// If the match fails the cursor will be positioned at the first failing token.
+-    #[must_use]
+-    pub fn match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> bool {
++    pub fn match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> Result<(), &'static str> {
+         let mut captures = captures.iter_mut();
+-        pats.iter().all(|&p| self.match_impl(p, &mut captures))
++        pats.iter()
++            .try_for_each(|&pat| self.match_impl(pat, &mut captures).ok_or(pat.desc()))
+     }
+ 
+     /// Attempts to match a sequence of patterns at the current position. Returns whether
+@@ -345,13 +430,16 @@ impl<'txt> Cursor<'txt> {
+     /// unmodified.
+     ///
+     /// If the match fails the cursor will be positioned at the first failing token.
+-    #[must_use]
+-    pub fn opt_match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> bool {
++    pub fn opt_match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> Result<bool, &'static str> {
+         let mut captures = captures.iter_mut();
+-        pats.iter()
++        match pats
++            .iter()
+             .try_for_each(|p| self.match_impl(*p, &mut captures).ok_or(p))
+-            .err()
+-            .is_none_or(|p| ptr::addr_eq(pats.as_ptr(), p))
++        {
++            Ok(()) => Ok(true),
++            Err(p) if ptr::addr_eq(pats.as_ptr(), p) => Ok(false),
++            Err(p) => Err(p.desc()),
++        }
+     }
+ }
+ 
+@@ -400,6 +488,8 @@ macro_rules! mk_tk_methods {
+     }
+ }
+ mk_tk_methods! {
++    ["`!`"]
++    bang(&mut self) { TokenKind::Bang }
+     ["`}`"]
+     close_brace(&mut self) { TokenKind::CloseBrace }
+     ["`]`"]
+diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
+index d3e95ffb87b40c4148a2ccbf85906a85bb4574d9..3680f167bc749fbdc341a479bcf0f4016ec64db2 100644
+--- a/clippy_dev/src/utils.rs
++++ b/clippy_dev/src/utils.rs
+@@ -1,4 +1,4 @@
+-use core::cell::Cell;
++use core::cell::{Cell, OnceCell};
+ use core::fmt::{self, Display, Write as _};
+ use core::hash::{Hash, Hasher};
+ use core::marker::PhantomData;
+@@ -8,6 +8,7 @@ use core::range::Range;
+ use core::str::FromStr;
+ use core::str::pattern::Pattern;
+ use core::{mem, ptr};
++use memchr::memchr_iter;
+ use rustc_arena::DroplessArena;
+ use std::ffi::OsStr;
+ use std::fs::{self, OpenOptions};
+@@ -799,18 +800,31 @@ impl<T> VecBuf<T> {
+ pub struct SourceFile<'cx> {
+     // `cargo dev rename_lint` needs to be able to rename files.
+     pub path: Cell<&'cx str>,
++    pub line_starts: OnceCell<Vec<u32>>,
+     pub contents: String,
+ }
+ impl<'cx> SourceFile<'cx> {
++    #[must_use]
+     pub fn load(path: &'cx str) -> Self {
+         let mut contents = String::new();
+         File::open_read(path).read_append_to_string(&mut contents);
+         SourceFile {
+             path: Cell::new(path),
++            line_starts: OnceCell::new(),
+             contents,
+         }
+     }
+ 
++    pub fn line_starts(&self) -> &[u32] {
++        self.line_starts.get_or_init(|| {
++            let mut line_starts = Vec::with_capacity(self.contents.len() / 32 + 4);
++            line_starts.push(0);
++            #[expect(clippy::cast_possible_truncation)]
++            line_starts.extend(memchr_iter(b'\n', self.contents.as_bytes()).map(|x| x as u32 + 1));
++            line_starts
++        })
++    }
++
+     /// Splits the file's path into the crate it's a part of and the module it implements.
+     ///
+     /// Only supports paths in the form `CRATE_NAME/src/PATH/TO/FILE.rs` using the current

patches/20261028T105419Z/rust-lang--rust-part011/5fae19c02516f3b1dc3eb5e2e3532b19d9b9f390.patch

@@ -0,0 +1,232 @@
+diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
+index 9799208efdb2a41cba705c9bb78971a6ccb0fe9d..41f98e2fb40c0a367d32bac14b13cbd1fa9178c6 100644
+--- a/compiler/rustc_hir_analysis/src/lib.rs
++++ b/compiler/rustc_hir_analysis/src/lib.rs
+@@ -194,6 +194,16 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
+         {
+             tcx.ensure_ok().typeck(item_def_id);
+         }
++    });
++
++    // This has to be a second pass over the body owners, after every body has been
++    // type-checked above. `needs_coroutine_by_move_body_def_id` asks for `type_of`, and for a
++    // body owner nested inside a const argument's anon const that goes through `typeck` of the
++    // anon const, which needs the anon const's own type. That type is never computed, only fed
++    // while the enclosing body is type-checked. Doing this in the pass above lets the parallel
++    // front end reach the nested body owner first, computing (and caching) an error type for
++    // the anon const that then conflicts with the type fed later on.
++    tcx.par_hir_body_owners(|item_def_id| {
+         // Ensure we generate the new `DefId` before finishing `check_crate`.
+         // Afterwards we freeze the list of `DefId`s.
+         if tcx.needs_coroutine_by_move_body_def_id(item_def_id.to_def_id()) {
+diff --git a/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.rs b/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..e10f46176ebb3d5e789ade3a39765c00698ebdca
+--- /dev/null
++++ b/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.rs
+@@ -0,0 +1,12 @@
++//@ edition: 2024
++//@ compile-flags: -Zthreads=0 --crate-type lib
++
++#![allow(dead_code)]
++#![allow(invalid_type_param_default)]
++
++fn f<const N: u8, T = ()>() {
++    f::<{ async || {} }>();
++    //~^ ERROR mismatched types
++}
++
++//@ normalize-stderr: "found `\{async closure@[^`]*\}`" -> "found `{async closure@...}`"
+diff --git a/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.stderr b/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.stderr
+new file mode 100644
+index 0000000000000000000000000000000000000000..33071f2a3a8df28de9437263c925a0445b521045
+--- /dev/null
++++ b/tests/ui/const-generics/anon-const-type-of-defaulted-param-issue-158818.stderr
+@@ -0,0 +1,22 @@
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-defaulted-param-issue-158818.rs:8:11
++   |
++LL |     f::<{ async || {} }>();
++   |           ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@$DIR/anon-const-type-of-defaulted-param-issue-158818.rs:8:11: 8:19}`
++
++error: aborting due to 1 previous error
++
++For more information about this error, try `rustc --explain E0308`.
++Future incompatibility report: Future breakage diagnostic:
++warning: defaults for generic parameters are not allowed here
++  --> $DIR/anon-const-type-of-defaulted-param-issue-158818.rs:7:19
++   |
++LL | fn f<const N: u8, T = ()>() {
++   |                   ^^^^^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
++
+diff --git a/tests/ui/const-generics/anon-const-type-of-issue-158818.rs b/tests/ui/const-generics/anon-const-type-of-issue-158818.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..3052ceefa4759a33bb25db836c72c80de7aec5b2
+--- /dev/null
++++ b/tests/ui/const-generics/anon-const-type-of-issue-158818.rs
+@@ -0,0 +1,69 @@
++// The type of a const argument's anon const is never computed, only fed while the enclosing body
++// is type-checked. Under the parallel front end, `check_crate` used to ask for the `type_of` of a
++// body owner nested inside such an anon const before that had happened, computing and caching an
++// error type that then conflicted with the type fed later on.
++//
++// Each case below reaches the anon const through a different kind of path or position, none of
++// which is resolved before the enclosing body is type-checked. They all live in one body so that
++// the parallel front end cannot interleave their diagnostics.
++
++//@ edition: 2024
++//@ compile-flags: -Zthreads=0 --crate-type lib
++
++#![allow(dead_code)]
++
++struct Foo<const N: u8>;
++struct Tuple<const N: u8>(u8);
++
++trait Trait {
++    fn assoc<const N: u8>();
++}
++
++impl Trait for Foo<0> {
++    fn assoc<const N: u8>() {}
++}
++
++impl<const N: u8> Foo<N> {
++    fn inherent<const M: u8>() {}
++}
++
++mod submodule {
++    pub fn free<const N: u8>() {}
++}
++
++fn free<const N: u8>() {}
++
++fn preceded<T, const N: u8>() {}
++
++// The late-bound `'a` is not a generic parameter, leaving this function with fewer parameters
++// than it declares. Elided late-bound lifetimes in the signature do the same.
++fn late_bound<'a, const N: u8>(_: &'a ()) {}
++
++// `impl Sized` is a synthetic parameter, with no argument of its own.
++fn synthetic<const N: u8>(_: impl Sized) {}
++
++fn cases() {
++    free::<{ async || {} }>();
++    //~^ ERROR mismatched types
++    submodule::free::<{ async || {} }>();
++    //~^ ERROR mismatched types
++    preceded::<u8, { async || {} }>();
++    //~^ ERROR mismatched types
++    late_bound::<{ async || {} }>(&());
++    //~^ ERROR mismatched types
++    synthetic::<{ async || {} }>(());
++    //~^ ERROR mismatched types
++    <Foo<0> as Trait>::assoc::<{ async || {} }>();
++    //~^ ERROR mismatched types
++    Foo::<0>::inherent::<{ async || {} }>();
++    //~^ ERROR mismatched types
++    let _ = Tuple::<{ async || {} }>(0);
++    //~^ ERROR mismatched types
++
++    // Not a path expression at all: the const argument sits in a type annotation, and is only
++    // lowered once typeck reaches this statement.
++    let _: Foo<{ async || {} }>;
++    //~^ ERROR mismatched types
++}
++
++//@ normalize-stderr: "\{async closure@[^`]*\}" -> "{async closure@...}"
+diff --git a/tests/ui/const-generics/anon-const-type-of-issue-158818.stderr b/tests/ui/const-generics/anon-const-type-of-issue-158818.stderr
+new file mode 100644
+index 0000000000000000000000000000000000000000..d0ee9786e294cc96784f3f56f3ca22bb25ca73da
+--- /dev/null
++++ b/tests/ui/const-generics/anon-const-type-of-issue-158818.stderr
+@@ -0,0 +1,84 @@
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:46:14
++   |
++LL |     free::<{ async || {} }>();
++   |              ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:48:25
++   |
++LL |     submodule::free::<{ async || {} }>();
++   |                         ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:50:22
++   |
++LL |     preceded::<u8, { async || {} }>();
++   |                      ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:52:20
++   |
++LL |     late_bound::<{ async || {} }>(&());
++   |                    ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:54:19
++   |
++LL |     synthetic::<{ async || {} }>(());
++   |                   ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:56:34
++   |
++LL |     <Foo<0> as Trait>::assoc::<{ async || {} }>();
++   |                                  ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:58:28
++   |
++LL |     Foo::<0>::inherent::<{ async || {} }>();
++   |                            ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:60:23
++   |
++LL |     let _ = Tuple::<{ async || {} }>(0);
++   |                       ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error[E0308]: mismatched types
++  --> $DIR/anon-const-type-of-issue-158818.rs:65:18
++   |
++LL |     let _: Foo<{ async || {} }>;
++   |                  ^^^^^^^^^^^ expected `u8`, found `{async closure@...}`
++   |
++   = note: expected type `u8`
++           found closure `{async closure@...}`
++
++error: aborting due to 9 previous errors
++
++For more information about this error, try `rustc --explain E0308`.

patches/20261028T105419Z/rust-lang--rust-part011/610f6ff258262a85cc1fe6fe5cd8ca300953ff04.patch

@@ -0,0 +1,43 @@
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+index f247b517c541f01265bf0ef22d8996647a584d2e..fc53d64a2f984b7ead7cc479dfc4b652ecb5accd 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+@@ -1329,7 +1329,11 @@ impl<'db> InferenceContext<'db> {
+             }
+             None => {
+                 let ty = self.table.next_ty_var(element.into());
+-                self.infer_expr(element, &Expectation::has_type(ty), ExprIsRead::Yes);
++                self.infer_expr_suptype_coerce_never(
++                    element,
++                    &Expectation::has_type(ty),
++                    ExprIsRead::Yes,
++                );
+                 ty
+             }
+         };
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+index 1c5f8aa110463cefa4b5a755eb01edfb4594da70..e53f7503dac6b6c7ae207df54a7a73aefabcfefb 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+@@ -114,6 +114,21 @@ fn test() {
+     );
+ }
+ 
++#[test]
++fn array_repeat_never_can_be_reinferred() {
++    check_no_mismatches(
++        r#"
++fn test() {
++    let y = [return; 2];
++    match y {
++        [(1, _), (_, false)] => {}
++        [_, _] => {}
++    }
++}
++"#,
++    );
++}
++
+ #[test]
+ fn match_no_arm() {
+     check_types(

patches/20261028T105419Z/rust-lang--rust-part011/6423eed93f6662dee0d087dd3f237de0aaca69b0.patch

@@ -0,0 +1,240 @@
+diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
+index af517fbd8f4d095cb077ccaa1dac3de088cb0e2e..811536a5f221e6c0b227b6b4fd3cc5b11cc4987a 100644
+--- a/compiler/rustc_lint_defs/src/builtin.rs
++++ b/compiler/rustc_lint_defs/src/builtin.rs
+@@ -278,18 +278,25 @@ declare_lint! {
+ }
+ 
+ declare_lint! {
+-    /// Todo: explain this.
++    /// The `repeated_reprs` lint detects when the same representation is
++    /// specified more than once in a `#[repr(..)]` attribute.
+     ///
+     /// ### Example
+     ///
+-    /// TODO
++    /// ```rust
++    /// #[repr(C)]
++    /// #[repr(C)]
++    /// enum Foo { A }
++    /// ```
+     ///
+     /// ### Explanation
+     ///
+-    /// TODO
++    /// While some representations may be specified more than once, the compiler
++    /// will reject repeated uses of some others. For consistency, prefer to
++    /// only specify the representation once.
+     pub REPEATED_REPRS,
+     Warn,
+-    "repeated `#[repr(..)]` attributes were inconsistently rejected before",
++    "detects repeated representations in `#[repr(..)]` attributes",
+ }
+ 
+ declare_lint! {
+diff --git a/compiler/rustc_passes/src/diagnostics.rs b/compiler/rustc_passes/src/diagnostics.rs
+index deae750ca26881053af44285b9953a2bbb57a4e1..2f4900a6b47a7f9fab09272d1f00e63c83aea784 100644
+--- a/compiler/rustc_passes/src/diagnostics.rs
++++ b/compiler/rustc_passes/src/diagnostics.rs
+@@ -608,8 +608,8 @@ pub(crate) struct TransparentIncompatible {
+ }
+ 
+ #[derive(Diagnostic)]
+-#[diag("attribute is specified more than once")]
+-#[note("will become a hard error soon. todo: wording")]
++#[diag("representation attribute is specified more than once")]
++#[note("for consistency, only specify the representation once")]
+ pub(crate) struct RepeatedRepr;
+ 
+ #[derive(Diagnostic)]
+diff --git a/tests/ui/attributes/issue-100631.rs b/tests/ui/attributes/issue-100631.rs
+index 0f0eb235aae7840ee6cc5b4422c45e11586024da..d496231c730263d049edd9f92427c9fba9b9270b 100644
+--- a/tests/ui/attributes/issue-100631.rs
++++ b/tests/ui/attributes/issue-100631.rs
+@@ -2,7 +2,7 @@
+ // can reasonably deal with multiple attributes.
+ // `repr` will use `TyCtxt::get_attrs` since it's `DuplicatesOk`.
+ #[repr(C)] //~ ERROR: unsupported representation for zero-variant enum [E0084]
+-//~^ WARN attribute is specified more than once
++//~^ WARN representation attribute is specified more than once
+ #[repr(C)]
+ enum Foo {}
+ 
+diff --git a/tests/ui/attributes/issue-100631.stderr b/tests/ui/attributes/issue-100631.stderr
+index 8f9cc9defcde0684b42081d32305a1bfe1204ab2..66e08738eb02c24dca94beab59ba9114006dedd9 100644
+--- a/tests/ui/attributes/issue-100631.stderr
++++ b/tests/ui/attributes/issue-100631.stderr
+@@ -1,4 +1,4 @@
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/issue-100631.rs:4:8
+    |
+ LL | #[repr(C)]
+@@ -7,7 +7,7 @@ LL |
+ LL | #[repr(C)]
+    |        ^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+    = note: `#[warn(repeated_reprs)]` on by default
+ 
+ error[E0084]: unsupported representation for zero-variant enum
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.rs b/tests/ui/lint/unused/unused-attr-duplicate.rs
+index 6a1dfd702cf06bd113d61a8f754c182fde53f7a6..348c9590e8b27be1ab5e99cb24d90b724e4371d6 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.rs
++++ b/tests/ui/lint/unused/unused-attr-duplicate.rs
+@@ -64,7 +64,7 @@ fn t1() {}
+ #[must_use = "some message"]
+ //~^ ERROR unused attribute
+ //~| WARN this was previously accepted
+-#[repr(C)] //~ WARN attribute is specified more than once
++#[repr(C)] //~ WARN representation attribute is specified more than once
+ #[repr(C)]
+ #[non_exhaustive]
+ #[non_exhaustive] //~ ERROR unused attribute
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+index 10a674cc0332578f45c7a70faa45acf77c31d083..93f7a4791188f2c9138f737b8a58e7e6d4a3471d 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
++++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+@@ -16,7 +16,7 @@ note: the lint level is defined here
+ LL | #![deny(unused_attributes)]
+    |         ^^^^^^^^^^^^^^^^^
+ 
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/unused-attr-duplicate.rs:67:8
+    |
+ LL | #[repr(C)]
+@@ -24,7 +24,7 @@ LL | #[repr(C)]
+ LL | #[repr(C)]
+    |        ^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+    = note: `#[warn(repeated_reprs)]` on by default
+ 
+ error: unused attribute
+diff --git a/tests/ui/repr/conflicting-repr-hints.rs b/tests/ui/repr/conflicting-repr-hints.rs
+index 0ddcabef67972c41d84ccd44b338df56016c191a..032f2b2e6c6083abe234780cd8a434f8e6e0cb75 100644
+--- a/tests/ui/repr/conflicting-repr-hints.rs
++++ b/tests/ui/repr/conflicting-repr-hints.rs
+@@ -36,10 +36,10 @@ struct G(i32); //~ ERROR type has conflicting packed and align representation hi
+ #[repr(packed)]
+ struct H(i32); //~ ERROR type has conflicting packed and align representation hints
+ 
+-#[repr(packed, packed(2))] //~ WARN attribute is specified more than once
++#[repr(packed, packed(2))] //~ WARN representation attribute is specified more than once
+ struct I(i32); //~ ERROR type has conflicting packed representation hints
+ 
+-#[repr(packed(2))] //~ WARN attribute is specified more than once
++#[repr(packed(2))] //~ WARN representation attribute is specified more than once
+ #[repr(packed)]
+ struct J(i32); //~ ERROR type has conflicting packed representation hints
+ 
+diff --git a/tests/ui/repr/conflicting-repr-hints.stderr b/tests/ui/repr/conflicting-repr-hints.stderr
+index 77ff01a22caa5469a84587809533864fef2c1272..a99546b75478578638f4b83418858cf8ae6abca5 100644
+--- a/tests/ui/repr/conflicting-repr-hints.stderr
++++ b/tests/ui/repr/conflicting-repr-hints.stderr
+@@ -17,16 +17,16 @@ LL | #[repr(u32, u64)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/conflicting-repr-hints.rs:39:8
+    |
+ LL | #[repr(packed, packed(2))]
+    |        ^^^^^^  ^^^^^^^^^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+    = note: `#[warn(repeated_reprs)]` on by default
+ 
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/conflicting-repr-hints.rs:42:8
+    |
+ LL | #[repr(packed(2))]
+@@ -34,15 +34,15 @@ LL | #[repr(packed(2))]
+ LL | #[repr(packed)]
+    |        ^^^^^^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+ 
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/conflicting-repr-hints.rs:46:8
+    |
+ LL | #[repr(packed, packed(1))]
+    |        ^^^^^^  ^^^^^^^^^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+   --> $DIR/conflicting-repr-hints.rs:29:1
+diff --git a/tests/ui/structs-enums/align-enum.rs b/tests/ui/structs-enums/align-enum.rs
+index c9652ac84db47814b2ea2a1934e46012feaebafa..a635af7352afef14867f6dee2991d1e7e433da37 100644
+--- a/tests/ui/structs-enums/align-enum.rs
++++ b/tests/ui/structs-enums/align-enum.rs
+@@ -11,7 +11,7 @@ enum Align16 {
+ }
+ 
+ // Raise alignment by maximum
+-#[repr(align(1), align(16))] //~ WARN attribute is specified more than once
++#[repr(align(1), align(16))] //~ WARN representation attribute is specified more than once
+ #[repr(align(32))]
+ #[repr(align(4))]
+ enum Align32 {
+diff --git a/tests/ui/structs-enums/align-enum.stderr b/tests/ui/structs-enums/align-enum.stderr
+index 25fec15cf2a1209cf5618c6a40dcc500ab7bb188..9b8c9842f81dfcee9e39c1adf163705a38f6cba9 100644
+--- a/tests/ui/structs-enums/align-enum.stderr
++++ b/tests/ui/structs-enums/align-enum.stderr
+@@ -1,4 +1,4 @@
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/align-enum.rs:14:8
+    |
+ LL | #[repr(align(1), align(16))]
+@@ -8,7 +8,7 @@ LL | #[repr(align(32))]
+ LL | #[repr(align(4))]
+    |        ^^^^^^^^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+    = note: `#[warn(repeated_reprs)]` on by default
+ 
+ warning: 1 warning emitted
+diff --git a/tests/ui/structs-enums/align-struct.rs b/tests/ui/structs-enums/align-struct.rs
+index 1b6d4dfa49755da16cacb7fc1d0abea70ee613fa..2d1ebf6731a626209afbe0cc30632e41c0e9d84a 100644
+--- a/tests/ui/structs-enums/align-struct.rs
++++ b/tests/ui/structs-enums/align-struct.rs
+@@ -13,7 +13,7 @@ struct Align16(i32);
+ struct Align1(i32);
+ 
+ // Multiple attributes take the max
+-#[repr(align(4))] //~ WARN attribute is specified more than once
++#[repr(align(4))] //~ WARN representation attribute is specified more than once
+ #[repr(align(16))]
+ #[repr(align(8))]
+ struct AlignMany(i32);
+diff --git a/tests/ui/structs-enums/align-struct.stderr b/tests/ui/structs-enums/align-struct.stderr
+index 6aaafc8c7753d6e34467106a42821f273b17a946..f54e9cd14cd8bd22de5600fa23ccf02a94153c41 100644
+--- a/tests/ui/structs-enums/align-struct.stderr
++++ b/tests/ui/structs-enums/align-struct.stderr
+@@ -1,4 +1,4 @@
+-warning: attribute is specified more than once
++warning: representation attribute is specified more than once
+   --> $DIR/align-struct.rs:16:8
+    |
+ LL | #[repr(align(4))]
+@@ -8,7 +8,7 @@ LL | #[repr(align(16))]
+ LL | #[repr(align(8))]
+    |        ^^^^^^^^
+    |
+-   = note: will become a hard error soon. todo: wording
++   = note: for consistency, only specify the representation once
+    = note: `#[warn(repeated_reprs)]` on by default
+ 
+ warning: 1 warning emitted

patches/20261028T105419Z/rust-lang--rust-part011/68c2ddf5d3d1f2bdb02a516625a4888f40a92a27.patch

@@ -0,0 +1,41 @@
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
+index bd1ad70fe6a1426882505480e825f479593916b6..44f410408a40a22aeee96517233852be11e31204 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
+@@ -491,6 +491,12 @@ impl<'db> MirLowerCtx<'_, 'db> {
+                 )?
+             }
+             Pat::Ref { pat, mutability: _ } => {
++                let ty = cond_place.ty(&self.result, &self.infcx, self.env).ty;
++                if !ty.is_ref() {
++                    return Err(MirLowerError::TypeError(
++                        "non reference type matched with reference pattern",
++                    ));
++                }
+                 let cond_place = cond_place.project(ProjectionElem::Deref);
+                 self.pattern_match_inner(current, current_else, cond_place, *pat, mode)?
+             }
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
+index 1f6aa5c926b152448c2a1e737864e93f0cccdde1..e4f3b61be4556412eea887d5db2e7953fc6acbab 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
+@@ -49,3 +49,19 @@ fn foo() {
+     "#,
+     );
+ }
++
++#[test]
++fn ref_pattern_on_unresolved_alias() {
++    lower_mir(
++        r#"
++//- minicore: sized
++trait Tr {
++    type A;
++}
++
++fn f<T: Tr>(x: T::A) {
++    let &() = x;
++}
++"#,
++    );
++}

patches/20261028T105419Z/rust-lang--rust-part011/6c8bd24ec61a7f9bf0bd1e30eb664dd96f932985.patch

@@ -0,0 +1,15 @@
+diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
+index 39292b5d04309601a893fdaccb6e318af2d9cdfb..121f3c0a818504a71a47ca62dda8b343bb70b740 100644
+--- a/src/bootstrap/src/core/builder/cargo.rs
++++ b/src/bootstrap/src/core/builder/cargo.rs
+@@ -399,7 +399,9 @@ impl Cargo {
+                 // Do not enable Zlib compression on:
+                 // - Windows, because MSVC/PDB doesn't support it
+                 // - macOS, because its linker doesn't know the flag
+-                if !self.target.is_windows() && !self.target.is_apple() {
++                // - Cygwin, because its linker may not support the flag
++                if !self.target.is_windows() && !self.target.is_apple() && !self.target.is_cygwin()
++                {
+                     // If we link through cc, we need the -Wl prefix.
+                     // If we don't, then we must not add it, because the linker wouldn't
+                     // understand it.

patches/20261028T105419Z/rust-lang--rust-part011/6cabf9581df3b56951055bd63a250e2fda9f49ec.patch

@@ -0,0 +1,27 @@
+diff --git a/tests/ui-internal/custom_ice_message.rs b/tests/ui/custom_ice_message.rs
+similarity index 100%
+rename from tests/ui-internal/custom_ice_message.rs
+rename to tests/ui/custom_ice_message.rs
+diff --git a/tests/ui-internal/custom_ice_message.stderr b/tests/ui/custom_ice_message.stderr
+similarity index 89%
+rename from tests/ui-internal/custom_ice_message.stderr
+rename to tests/ui/custom_ice_message.stderr
+index 2e4d53104fba182e60364203463556ff8d3a4cf7..c21963007c89e95219a74dabfb37dfe69edf00aa 100644
+--- a/tests/ui-internal/custom_ice_message.stderr
++++ b/tests/ui/custom_ice_message.stderr
+@@ -3,13 +3,13 @@ note: no errors encountered even though delayed bugs were created
+ note: those delayed bugs will now be shown as internal compiler errors
+ 
+ error: internal compiler error: Would you like some help with that?
+-  --> tests/ui-internal/custom_ice_message.rs:12:1
++  --> tests/ui/custom_ice_message.rs:12:1
+    |
+ LL | fn it_looks_like_you_are_trying_to_kill_clippy() {}
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    |
+ note: delayed at clippy_lints_internal/src/produce_ice.rs - disabled backtrace
+-  --> tests/ui-internal/custom_ice_message.rs:12:1
++  --> tests/ui/custom_ice_message.rs:12:1
+    |
+ LL | fn it_looks_like_you_are_trying_to_kill_clippy() {}
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

patches/20261028T105419Z/rust-lang--rust-part011/70020cc60fdf32e67cbfc5818da8e3c7e34a1918.patch

@@ -0,0 +1,48 @@
+diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
+index c5117c4c83f7c2b70274ba3bf697b3784aeccc1f..f251fdb29ace275e8868e30bf0d930d56232bf16 100644
+--- a/src/etc/lldb_providers.py
++++ b/src/etc/lldb_providers.py
+@@ -1029,19 +1029,14 @@ class TupleSyntheticProvider:
+ 
+     def get_child_index(self, name: str) -> int:
+         if name.isdigit():
+-            return int(name)
++            return self.valobj.GetIndexOfChildWithName(f"__{name}")
+         else:
+             return -1
+ 
+     def get_child_at_index(self, index: int) -> Optional[SBValue]:
+-        if self.is_variant:
+-            field = self.type.GetFieldAtIndex(index + 1)
+-        else:
+-            field = self.type.GetFieldAtIndex(index)
+-        element = self.valobj.GetChildMemberWithName(field.name)
+-        return self.valobj.CreateValueFromData(
+-            str(index), element.GetData(), element.GetType()
+-        )
++        return self.valobj.GetChildAtIndex(
++            self.valobj.GetIndexOfChildWithName(f"__{index}")
++        ).Clone(str(index))
+ 
+     def update(self):
+         pass
+@@ -1060,12 +1055,15 @@ class MSVCTupleSyntheticProvider:
+         return self.valobj.GetNumChildren()
+ 
+     def get_child_index(self, name: str) -> int:
+-        return self.valobj.GetIndexOfChildWithName(name)
++        if name.isdigit():
++            return self.valobj.GetIndexOfChildWithName(f"__{name}")
++        else:
++            return -1
+ 
+     def get_child_at_index(self, index: int) -> Optional[SBValue]:
+-        child: SBValue = self.valobj.GetChildAtIndex(index)
+-        offset = self.valobj.GetType().GetFieldAtIndex(index).byte_offset
+-        return self.valobj.CreateChildAtOffset(str(index), offset, child.GetType())
++        return self.valobj.GetChildAtIndex(
++            self.valobj.GetIndexOfChildWithName(f"__{index}")
++        ).Clone(str(index))
+ 
+     def update(self):
+         pass

patches/20261028T105419Z/rust-lang--rust-part011/80f74433dbd201f6cf1eabf24820acf08993d110.patch

@@ -0,0 +1,74 @@
+diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+index 09ad3254e57146071d8b628b1a797ef5939c6953..b3b1bea68e0b42b3fc9a0089bb4c6ae59ca0c4da 100644
+--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
++++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+@@ -171,7 +171,6 @@ fn f16_builtin<'gcc, 'tcx>(
+         sym::exp2f16 => "exp2f",
+         sym::fabs => "fabsf",
+         sym::floorf16 => "__builtin_floorf",
+-        sym::fmaf16 => "fmaf",
+         sym::logf16 => "logf",
+         sym::log2f16 => "log2f",
+         sym::log10f16 => "log10f",
+@@ -249,7 +248,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
+             | sym::expf16
+             | sym::exp2f16
+             | sym::floorf16
+-            | sym::fmaf16
+             | sym::logf16
+             | sym::log2f16
+             | sym::log10f16
+diff --git a/library/coretests/tests/num/floats.rs b/library/coretests/tests/num/floats.rs
+index cc1d1a0b673dc0f2bb582cb0211aeaac14f021d4..8c3bc2f61b4fe9a65ddb3b5d0aa6c95630e0bb29 100644
+--- a/library/coretests/tests/num/floats.rs
++++ b/library/coretests/tests/num/floats.rs
+@@ -58,6 +58,9 @@ pub(crate) trait TestableFloat: Sized {
+     const RAW_MINUS_14_DOT_25: Self;
+     /// The result of 12.3.mul_add(4.5, 6.7)
+     const MUL_ADD_RESULT: Self;
++    /// The result of 48.34375.mul_add(0.000013887882, 0.12438965), which checks that f16::mul_add
++    /// is correctly rounded. A naive implementation via f32::mul_add has insufficient precision.
++    const F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT: Self;
+     /// The result of (-12.3).mul_add(-4.5, -6.7)
+     const NEG_MUL_ADD_RESULT: Self;
+     /// Reciprocal of the maximum val
+@@ -109,6 +112,7 @@ impl TestableFloat for f16 {
+     const RAW_1337: Self = Self::from_bits(0x6539);
+     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xcb20);
+     const MUL_ADD_RESULT: Self = 62.031;
++    const F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT: Self = 0.1251;
+     const NEG_MUL_ADD_RESULT: Self = 48.625;
+     const MAX_RECIP: Self = 1.526624e-5;
+     const ASINH_ACOSH_MAX: Self = 11.781;
+@@ -168,6 +172,7 @@ impl TestableFloat for f32 {
+     const RAW_1337: Self = Self::from_bits(0x44a72000);
+     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc1640000);
+     const MUL_ADD_RESULT: Self = 62.05;
++    const F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT: Self = 0.12506104;
+     const NEG_MUL_ADD_RESULT: Self = 48.65;
+     const MAX_RECIP: Self = 2.938736e-39;
+     const ASINH_ACOSH_MAX: Self = 89.4159851;
+@@ -200,6 +205,7 @@ impl TestableFloat for f64 {
+     const RAW_1337: Self = Self::from_bits(0x4094e40000000000);
+     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc02c800000000000);
+     const MUL_ADD_RESULT: Self = 62.050000000000004;
++    const F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT: Self = 0.1250610422954375;
+     const NEG_MUL_ADD_RESULT: Self = 48.650000000000006;
+     const MAX_RECIP: Self = 5.562684646268003e-309;
+     const ASINH_ACOSH_MAX: Self = 710.47586007394398;
+@@ -242,6 +248,7 @@ impl TestableFloat for f128 {
+     const RAW_1337: Self = Self::from_bits(0x40094e40000000000000000000000000);
+     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc002c800000000000000000000000000);
+     const MUL_ADD_RESULT: Self = 62.0500000000000000000000000000000037;
++    const F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT: Self = 0.1250610422954375;
+     const NEG_MUL_ADD_RESULT: Self = 48.6500000000000000000000000000000049;
+     const MAX_RECIP: Self = 8.40525785778023376565669454330438228902076605e-4933;
+     const ASINH_ACOSH_MAX: Self = 11357.216553474703894801348310092223;
+@@ -1978,6 +1985,7 @@ float_test! {
+         let inf: Float = Float::INFINITY;
+         let neg_inf: Float = Float::NEG_INFINITY;
+         assert_biteq!(flt(12.3).mul_add(flt(4.5), flt(6.7)), Float::MUL_ADD_RESULT);
++        assert_biteq!(flt( 48.34375).mul_add(flt(0.000013887882), flt(0.12438965)), Float::F16_NO_DOUBLE_ROUNDING_MUL_ADD_RESULT);
+         assert_biteq!((flt(-12.3)).mul_add(flt(-4.5), flt(-6.7)), Float::NEG_MUL_ADD_RESULT);
+         assert_biteq!(flt(0.0).mul_add(8.9, 1.2), 1.2);
+         assert_biteq!(flt(3.4).mul_add(-0.0, 5.6), 5.6);

patches/20261028T105419Z/rust-lang--rust-part011/819099b56c2c69e5ed886b4b4f1c572beefa749d.patch

@@ -0,0 +1,639 @@
+diff --git a/compiler/rustc_attr_ir/src/data_structures.rs b/compiler/rustc_attr_ir/src/data_structures.rs
+index 195712559782ddd3686569b16f64493272da80cb..28e90ea4f52b4d28cd590b796cfe925584646bfd 100644
+--- a/compiler/rustc_attr_ir/src/data_structures.rs
++++ b/compiler/rustc_attr_ir/src/data_structures.rs
+@@ -172,7 +172,19 @@ impl OptimizeAttr {
+     }
+ }
+ 
+-#[derive(PartialEq, Debug, Encodable, Decodable, Copy, Clone, StableHash, PrintAttribute)]
++#[derive(
++    PartialEq,
++    Eq,
++    Debug,
++    PartialOrd,
++    Ord,
++    Encodable,
++    Decodable,
++    Copy,
++    Clone,
++    StableHash,
++    PrintAttribute
++)]
+ pub enum ReprAttr {
+     ReprInt(IntType),
+     ReprRust,
+@@ -188,7 +200,7 @@ pub enum TransparencyError {
+     MultipleTransparencyAttrs(Span, Span),
+ }
+ 
+-#[derive(Eq, PartialEq, Debug, Copy, Clone)]
++#[derive(Eq, PartialEq, Debug, Copy, Clone, PartialOrd, Ord)]
+ #[derive(Encodable, Decodable, StableHash, PrintAttribute)]
+ pub enum IntType {
+     SignedInt(ast::IntTy),
+diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
+index b196ae1e5a82edb2552c84e4529bc44ba6d5b1d7..e4ee552d5bd0ebeb1c59e2f0f49625bcd67c3eb0 100644
+--- a/compiler/rustc_passes/src/check_attr.rs
++++ b/compiler/rustc_passes/src/check_attr.rs
+@@ -1213,64 +1213,58 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
+         let mut is_c = false;
+         let mut is_simd = false;
+         let mut is_transparent = false;
+-        let mut is_align = false;
+-        let mut is_packed = false;
+-        let mut repeated_repr = false;
+-        let mut maybe_last_int_type = None;
+ 
+         for (repr, _repr_span) in reprs {
+             match repr {
+                 ReprAttr::ReprRust => {
+-                    if is_explicit_rust {
+-                        repeated_repr = true;
+-                    }
+                     is_explicit_rust = true;
+                 }
+                 ReprAttr::ReprC => {
+-                    if is_c {
+-                        repeated_repr = true;
+-                    }
+                     is_c = true;
+                 }
+-                ReprAttr::ReprAlign(..) => {
+-                    if is_align {
+-                        repeated_repr = true;
+-                    }
+-                    is_align = true;
+-                }
+-                ReprAttr::ReprPacked(..) => {
+-                    if is_packed {
+-                        repeated_repr = true;
+-                    }
+-                    is_packed = true;
+-                }
++                ReprAttr::ReprAlign(..) => (),
++                ReprAttr::ReprPacked(..) => (),
+                 ReprAttr::ReprSimd => {
+-                    if is_simd {
+-                        repeated_repr = true;
+-                    }
+                     is_simd = true;
+                 }
+                 ReprAttr::ReprTransparent => {
+-                    // No need to check for repeated transparent because that is already checked
+-                    // when checking for any other attribute together with transparent.
+                     is_transparent = true;
+                 }
+-                ReprAttr::ReprInt(int_type) => {
+-                    if let Some(last_int_type) = maybe_last_int_type
+-                        && last_int_type == int_type
+-                    {
+-                        // We'll "miss" detecting repeated int reprs if the user specifies
+-                        // #[repr(u8, u64, u8)] for example. But that's okay because we've got
+-                        // conflicting reprs anyway so it's not worth the effort to do more precise
+-                        // tracking.
+-                        repeated_repr = true;
+-                    }
+-                    maybe_last_int_type = Some(int_type);
++                ReprAttr::ReprInt(..) => {
+                     int_reprs += 1;
+                 }
+             };
+         }
+ 
++        if !reprs.is_empty() {
++            let sorted_reprs = {
++                let mut to_sort = reprs.to_owned();
++                to_sort.sort_unstable();
++                to_sort
++            };
++
++            // To collect all duplicates, get subslices where all of the elements of the subslice
++            // are equal, then filter out all those whose length is not 1. We could return warnings
++            // for each of them, but that's annoyingly excessive. So we instead collect all spans in
++            // one big Vec.
++            let spans: Vec<Span> = sorted_reprs
++                .chunk_by(|(a, _), (b, _)| a == b)
++                .map(ToOwned::to_owned)
++                .filter(|slice| slice.len() != 1)
++                .flatten()
++                .map(|(_, span)| span)
++                .collect();
++
++            if !spans.is_empty() {
++                self.tcx.emit_node_span_lint(
++                    REPEATED_REPRS,
++                    hir_id,
++                    spans,
++                    diagnostics::RepeatedRepr,
++                );
++            }
++        }
++
+         // Just point at all repr hints if there are any incompatibilities.
+         // This is not ideal, but tracking precisely which ones are at fault is a huge hassle.
+         let hint_spans = reprs.iter().map(|(_, span)| *span);
+@@ -1306,17 +1300,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
+             self.tcx.emit_node_span_lint(
+                 CONFLICTING_REPR_HINTS,
+                 hir_id,
+-                hint_spans.clone().collect::<Vec<Span>>(),
+-                diagnostics::ReprConflictingLint,
+-            );
+-        }
+-
+-        if repeated_repr {
+-            self.tcx.emit_node_span_lint(
+-                REPEATED_REPRS,
+-                hir_id,
+                 hint_spans.collect::<Vec<Span>>(),
+-                diagnostics::RepeatedRepr,
++                diagnostics::ReprConflictingLint,
+             );
+         }
+     }
+diff --git a/compiler/rustc_passes/src/diagnostics.rs b/compiler/rustc_passes/src/diagnostics.rs
+index 2f4900a6b47a7f9fab09272d1f00e63c83aea784..c343d9c7078e7f9dd4f05e16200c587e67e519ba 100644
+--- a/compiler/rustc_passes/src/diagnostics.rs
++++ b/compiler/rustc_passes/src/diagnostics.rs
+@@ -608,7 +608,7 @@ pub(crate) struct TransparentIncompatible {
+ }
+ 
+ #[derive(Diagnostic)]
+-#[diag("representation attribute is specified more than once")]
++#[diag("`#[repr(..)]` attribute is specified more than once")]
+ #[note("for consistency, only specify the representation once")]
+ pub(crate) struct RepeatedRepr;
+ 
+diff --git a/tests/ui/attributes/issue-100631.rs b/tests/ui/attributes/issue-100631.rs
+index d496231c730263d049edd9f92427c9fba9b9270b..9a30691a39ec38723ec803c8dcfe4dff4fb0e043 100644
+--- a/tests/ui/attributes/issue-100631.rs
++++ b/tests/ui/attributes/issue-100631.rs
+@@ -2,7 +2,7 @@
+ // can reasonably deal with multiple attributes.
+ // `repr` will use `TyCtxt::get_attrs` since it's `DuplicatesOk`.
+ #[repr(C)] //~ ERROR: unsupported representation for zero-variant enum [E0084]
+-//~^ WARN representation attribute is specified more than once
++//~^ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ #[repr(C)]
+ enum Foo {}
+ 
+diff --git a/tests/ui/attributes/issue-100631.stderr b/tests/ui/attributes/issue-100631.stderr
+index 66e08738eb02c24dca94beab59ba9114006dedd9..0ecc19ae85b3d9d8851ddef81a0ec6da492983e4 100644
+--- a/tests/ui/attributes/issue-100631.stderr
++++ b/tests/ui/attributes/issue-100631.stderr
+@@ -1,4 +1,4 @@
+-warning: representation attribute is specified more than once
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/issue-100631.rs:4:8
+    |
+ LL | #[repr(C)]
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.rs b/tests/ui/lint/unused/unused-attr-duplicate.rs
+index 348c9590e8b27be1ab5e99cb24d90b724e4371d6..c013041ed4159192965aee2df1ce33862ba01b26 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.rs
++++ b/tests/ui/lint/unused/unused-attr-duplicate.rs
+@@ -64,7 +64,7 @@ fn t1() {}
+ #[must_use = "some message"]
+ //~^ ERROR unused attribute
+ //~| WARN this was previously accepted
+-#[repr(C)] //~ WARN representation attribute is specified more than once
++#[repr(C)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ #[repr(C)]
+ #[non_exhaustive]
+ #[non_exhaustive] //~ ERROR unused attribute
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+index 93f7a4791188f2c9138f737b8a58e7e6d4a3471d..6e4f7d23604c29224329ba678d8a5ffb514e2d01 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
++++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+@@ -16,7 +16,7 @@ note: the lint level is defined here
+ LL | #![deny(unused_attributes)]
+    |         ^^^^^^^^^^^^^^^^^
+ 
+-warning: representation attribute is specified more than once
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/unused-attr-duplicate.rs:67:8
+    |
+ LL | #[repr(C)]
+@@ -264,19 +264,6 @@ note: attribute also specified here
+ LL | #[track_caller]
+    | ^^^^^^^^^^^^^^^
+ 
+-error: unused attribute
+-  --> $DIR/unused-attr-duplicate.rs:93:5
+-   |
+-LL |     #[link_name = "rust_dbg_extern_identity_u32"]
+-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+-   |
+-note: attribute also specified here
+-  --> $DIR/unused-attr-duplicate.rs:92:5
+-   |
+-LL |     #[link_name = "this_does_not_exist"]
+-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+-
+ error: unused attribute
+   --> $DIR/unused-attr-duplicate.rs:99:1
+    |
+@@ -328,13 +315,13 @@ LL | #[link_section = "__TEXT,__text"]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ 
+ error: unused attribute
+-  --> $DIR/unused-attr-duplicate.rs:94:5
++  --> $DIR/unused-attr-duplicate.rs:93:5
+    |
+ LL |     #[link_name = "rust_dbg_extern_identity_u32"]
+    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+    |
+ note: attribute also specified here
+-  --> $DIR/unused-attr-duplicate.rs:93:5
++  --> $DIR/unused-attr-duplicate.rs:92:5
+    |
+ LL |     #[link_name = "this_does_not_exist"]
+    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+diff --git a/tests/ui/repr/conflicting-repr-hints.rs b/tests/ui/repr/conflicting-repr-hints.rs
+index 032f2b2e6c6083abe234780cd8a434f8e6e0cb75..81a94aad78ff664db86444b89d0ce97815494c0a 100644
+--- a/tests/ui/repr/conflicting-repr-hints.rs
++++ b/tests/ui/repr/conflicting-repr-hints.rs
+@@ -36,10 +36,10 @@ struct G(i32); //~ ERROR type has conflicting packed and align representation hi
+ #[repr(packed)]
+ struct H(i32); //~ ERROR type has conflicting packed and align representation hints
+ 
+-#[repr(packed, packed(2))] //~ WARN representation attribute is specified more than once
++#[repr(packed, packed(2))]
+ struct I(i32); //~ ERROR type has conflicting packed representation hints
+ 
+-#[repr(packed(2))] //~ WARN representation attribute is specified more than once
++#[repr(packed(2))]
+ #[repr(packed)]
+ struct J(i32); //~ ERROR type has conflicting packed representation hints
+ 
+diff --git a/tests/ui/repr/conflicting-repr-hints.stderr b/tests/ui/repr/conflicting-repr-hints.stderr
+index a99546b75478578638f4b83418858cf8ae6abca5..8f2655fd716f186b5918e9d8e19250d2e4ac27fd 100644
+--- a/tests/ui/repr/conflicting-repr-hints.stderr
++++ b/tests/ui/repr/conflicting-repr-hints.stderr
+@@ -17,32 +17,14 @@ LL | #[repr(u32, u64)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-warning: representation attribute is specified more than once
+-  --> $DIR/conflicting-repr-hints.rs:39:8
+-   |
+-LL | #[repr(packed, packed(2))]
+-   |        ^^^^^^  ^^^^^^^^^
+-   |
+-   = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
+-
+-warning: representation attribute is specified more than once
+-  --> $DIR/conflicting-repr-hints.rs:42:8
+-   |
+-LL | #[repr(packed(2))]
+-   |        ^^^^^^^^^
+-LL | #[repr(packed)]
+-   |        ^^^^^^
+-   |
+-   = note: for consistency, only specify the representation once
+-
+-warning: representation attribute is specified more than once
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/conflicting-repr-hints.rs:46:8
+    |
+ LL | #[repr(packed, packed(1))]
+    |        ^^^^^^  ^^^^^^^^^
+    |
+    = note: for consistency, only specify the representation once
++   = note: `#[warn(repeated_reprs)]` on by default
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+   --> $DIR/conflicting-repr-hints.rs:29:1
+@@ -104,7 +86,7 @@ error[E0587]: type has conflicting packed and align representation hints
+ LL | pub union U {
+    | ^^^^^^^^^^^
+ 
+-error: aborting due to 12 previous errors; 3 warnings emitted
++error: aborting due to 12 previous errors; 1 warning emitted
+ 
+ Some errors have detailed explanations: E0566, E0587, E0634.
+ For more information about an error, try `rustc --explain E0566`.
+diff --git a/tests/ui/repr/repr-repeated-attrs.rs b/tests/ui/repr/repr-repeated-attrs.rs
+index 61e3ba05625d8dad51b0856ef0d66890e23026bb..7306b9192f09eb79deb39a8a9c4bc6b886591106 100644
+--- a/tests/ui/repr/repr-repeated-attrs.rs
++++ b/tests/ui/repr/repr-repeated-attrs.rs
+@@ -1,32 +1,32 @@
+ // Tests to ensure we warn on repeated `#[repr(..)]` attributes.
+ 
+-#[repr(transparent, transparent)]
++#[repr(transparent, transparent)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR transparent struct cannot have other repr hints
+ #[repr(transparent)]
+ struct SeveralTransparentReprs(*mut u8);
+ 
+-#[repr(transparent)]
++#[repr(transparent)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR transparent struct cannot have other repr hints
+ #[repr(transparent)]
+ struct MultilineOnly(*mut u8);
+ 
+ #[repr(Rust, Rust)]
+-//~^ WARN representation attribute is specified more than once
++//~^ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ struct SeveralRustReprs(u8);
+ 
+ #[repr(C, C)]
+-//~^ WARN representation attribute is specified more than once
++//~^ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ #[repr(C, C, C)]
+ struct SeveralC(u8);
+ 
+-#[repr(u8, u8)] //~ WARN representation attribute is specified more than once
++#[repr(u8, u8)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+ enum SeveralPrimitiveRerprs {
+     Variant,
+ }
+ 
+-#[repr(C, C, u8)] //~ WARN representation attribute is specified more than once
++#[repr(C, C, u8)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+ #[repr(C, u8, u8)]
+@@ -34,7 +34,7 @@ enum SeveralCAndPrims {
+     Variant(u8),
+ }
+ 
+-#[repr(Rust, u8, u8)] //~ WARN representation attribute is specified more than once
++#[repr(Rust, u8, u8)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR conflicting representation hints
+ //~^^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+@@ -42,7 +42,7 @@ enum RustAndPrimDisallowed {
+     Variant(u8),
+ }
+ 
+-#[repr(u8, u8)] //~ WARN representation attribute is specified more than once
++#[repr(u8, u8)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+ #[repr(u16)]
+@@ -58,7 +58,7 @@ enum CWithIntsCausesFCW1 {
+     B,
+ }
+ 
+-#[repr(C, C, u8, u8, u8)] //~ WARN representation attribute is specified more than once
++#[repr(C, C, u8, u8, u8)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR conflicting representation hints
+ //~| WARN this was previously accepted
+ enum CWithIntsCausesFCW2 {
+diff --git a/tests/ui/repr/repr-repeated-attrs.stderr b/tests/ui/repr/repr-repeated-attrs.stderr
+index 57af8ec804d76d672cb87f068efef3c13ec7f68a..a0b8b1d7da3cc58d1eae30809f115711a2b65948 100644
+--- a/tests/ui/repr/repr-repeated-attrs.stderr
++++ b/tests/ui/repr/repr-repeated-attrs.stderr
+@@ -1,3 +1,15 @@
++warning: `#[repr(..)]` attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:3:8
++   |
++LL | #[repr(transparent, transparent)]
++   |        ^^^^^^^^^^^  ^^^^^^^^^^^
++LL |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++   |
++   = note: for consistency, only specify the representation once
++   = note: `#[warn(repeated_reprs)]` on by default
++
+ error[E0692]: transparent struct cannot have other repr hints
+   --> $DIR/repr-repeated-attrs.rs:3:8
+    |
+@@ -7,6 +19,17 @@ LL |
+ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+ 
++warning: `#[repr(..)]` attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:8:8
++   |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++LL |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++   |
++   = note: for consistency, only specify the representation once
++
+ error[E0692]: transparent struct cannot have other repr hints
+   --> $DIR/repr-repeated-attrs.rs:8:8
+    |
+@@ -16,16 +39,15 @@ LL |
+ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+ 
+-warning: representation attribute is specified more than once
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/repr-repeated-attrs.rs:13:8
+    |
+ LL | #[repr(Rust, Rust)]
+    |        ^^^^  ^^^^
+    |
+    = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
+ 
+-warning: representation attribute is specified more than once
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/repr-repeated-attrs.rs:17:8
+    |
+ LL | #[repr(C, C)]
+@@ -36,25 +58,25 @@ LL | #[repr(C, C, C)]
+    |
+    = note: for consistency, only specify the representation once
+ 
+-error[E0566]: conflicting representation hints
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/repr-repeated-attrs.rs:22:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+    |
+-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+-   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+-   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++   = note: for consistency, only specify the representation once
+ 
+-warning: representation attribute is specified more than once
++error[E0566]: conflicting representation hints
+   --> $DIR/repr-repeated-attrs.rs:22:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+    |
+-   = note: for consistency, only specify the representation once
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
+ 
+-error[E0566]: conflicting representation hints
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/repr-repeated-attrs.rs:29:8
+    |
+ LL | #[repr(C, C, u8)]
+@@ -63,10 +85,9 @@ LL | #[repr(C, C, u8)]
+ LL | #[repr(C, u8, u8)]
+    |        ^  ^^  ^^
+    |
+-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+-   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: for consistency, only specify the representation once
+ 
+-warning: representation attribute is specified more than once
++error[E0566]: conflicting representation hints
+   --> $DIR/repr-repeated-attrs.rs:29:8
+    |
+ LL | #[repr(C, C, u8)]
+@@ -75,6 +96,15 @@ LL | #[repr(C, C, u8)]
+ LL | #[repr(C, u8, u8)]
+    |        ^  ^^  ^^
+    |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++warning: `#[repr(..)]` attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:37:14
++   |
++LL | #[repr(Rust, u8, u8)]
++   |              ^^  ^^
++   |
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+@@ -92,11 +122,11 @@ LL | #[repr(Rust, u8, u8)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-warning: representation attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:37:8
++warning: `#[repr(..)]` attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:45:8
+    |
+-LL | #[repr(Rust, u8, u8)]
+-   |        ^^^^  ^^  ^^
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
+    |
+    = note: for consistency, only specify the representation once
+ 
+@@ -112,17 +142,6 @@ LL | #[repr(u16)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-warning: representation attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:45:8
+-   |
+-LL | #[repr(u8, u8)]
+-   |        ^^  ^^
+-...
+-LL | #[repr(u16)]
+-   |        ^^^
+-   |
+-   = note: for consistency, only specify the representation once
+-
+ error[E0566]: conflicting representation hints
+   --> $DIR/repr-repeated-attrs.rs:53:8
+    |
+@@ -132,24 +151,24 @@ LL | #[repr(C, u8)]
+    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-error[E0566]: conflicting representation hints
++warning: `#[repr(..)]` attribute is specified more than once
+   --> $DIR/repr-repeated-attrs.rs:61:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+    |
+-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+-   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: for consistency, only specify the representation once
+ 
+-warning: representation attribute is specified more than once
++error[E0566]: conflicting representation hints
+   --> $DIR/repr-repeated-attrs.rs:61:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+    |
+-   = note: for consistency, only specify the representation once
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+-error: aborting due to 9 previous errors; 7 warnings emitted
++error: aborting due to 9 previous errors; 9 warnings emitted
+ 
+ Some errors have detailed explanations: E0566, E0692.
+ For more information about an error, try `rustc --explain E0566`.
+diff --git a/tests/ui/structs-enums/align-enum.rs b/tests/ui/structs-enums/align-enum.rs
+index a635af7352afef14867f6dee2991d1e7e433da37..ff80a19211cdaf69b7c6b179ec9aaeb01faa7da6 100644
+--- a/tests/ui/structs-enums/align-enum.rs
++++ b/tests/ui/structs-enums/align-enum.rs
+@@ -11,7 +11,7 @@ enum Align16 {
+ }
+ 
+ // Raise alignment by maximum
+-#[repr(align(1), align(16))] //~ WARN representation attribute is specified more than once
++#[repr(align(1), align(16))]
+ #[repr(align(32))]
+ #[repr(align(4))]
+ enum Align32 {
+diff --git a/tests/ui/structs-enums/align-enum.stderr b/tests/ui/structs-enums/align-enum.stderr
+deleted file mode 100644
+index 9b8c9842f81dfcee9e39c1adf163705a38f6cba9..0000000000000000000000000000000000000000
+--- a/tests/ui/structs-enums/align-enum.stderr
++++ /dev/null
+@@ -1,15 +0,0 @@
+-warning: representation attribute is specified more than once
+-  --> $DIR/align-enum.rs:14:8
+-   |
+-LL | #[repr(align(1), align(16))]
+-   |        ^^^^^^^^  ^^^^^^^^^
+-LL | #[repr(align(32))]
+-   |        ^^^^^^^^^
+-LL | #[repr(align(4))]
+-   |        ^^^^^^^^
+-   |
+-   = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
+-
+-warning: 1 warning emitted
+-
+diff --git a/tests/ui/structs-enums/align-struct.rs b/tests/ui/structs-enums/align-struct.rs
+index 2d1ebf6731a626209afbe0cc30632e41c0e9d84a..3d8dad6e324e31113587297ef09f5a50050e918d 100644
+--- a/tests/ui/structs-enums/align-struct.rs
++++ b/tests/ui/structs-enums/align-struct.rs
+@@ -13,7 +13,7 @@ struct Align16(i32);
+ struct Align1(i32);
+ 
+ // Multiple attributes take the max
+-#[repr(align(4))] //~ WARN representation attribute is specified more than once
++#[repr(align(4))]
+ #[repr(align(16))]
+ #[repr(align(8))]
+ struct AlignMany(i32);
+diff --git a/tests/ui/structs-enums/align-struct.stderr b/tests/ui/structs-enums/align-struct.stderr
+deleted file mode 100644
+index f54e9cd14cd8bd22de5600fa23ccf02a94153c41..0000000000000000000000000000000000000000
+--- a/tests/ui/structs-enums/align-struct.stderr
++++ /dev/null
+@@ -1,15 +0,0 @@
+-warning: representation attribute is specified more than once
+-  --> $DIR/align-struct.rs:16:8
+-   |
+-LL | #[repr(align(4))]
+-   |        ^^^^^^^^
+-LL | #[repr(align(16))]
+-   |        ^^^^^^^^^
+-LL | #[repr(align(8))]
+-   |        ^^^^^^^^
+-   |
+-   = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
+-
+-warning: 1 warning emitted
+-

patches/20261028T105419Z/rust-lang--rust-part011/8432202b58569eb29b4ca2750eb7eefea94c0f04.patch

@@ -0,0 +1,24 @@
+diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
+index f6930e0a60d429f37c5c63583ecd5a85397eeb2a..f59219c09dc286e952fc4f360d17fe73f847e3fc 100644
+--- a/library/core/src/char/methods.rs
++++ b/library/core/src/char/methods.rs
+@@ -1,5 +1,7 @@
+ //! impl char {}
+ 
++#![expect(clippy::manual_is_ascii_check, reason = "this module implements various is_ascii checks")]
++
+ use super::*;
+ use crate::panic::const_panic;
+ use crate::slice;
+diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
+index 3fe7b95283446b0ae82db3f7eb6f22d694d18d91..59e470800dbd39e89ec91414addc9d7ab9e91612 100644
+--- a/library/core/src/num/mod.rs
++++ b/library/core/src/num/mod.rs
+@@ -1,6 +1,7 @@
+ //! Numeric traits and functions for the built-in numeric types.
+ 
+ #![stable(feature = "rust1", since = "1.0.0")]
++#![expect(clippy::manual_is_ascii_check, reason = "this module implements various is_ascii checks")]
+ 
+ use crate::convert::{BoundedCastFromInt, CheckedCastFromInt};
+ use crate::panic::const_panic;

patches/20261028T105419Z/rust-lang--rust-part011/844b744a9962206de8c877d881a0a4edfe24b5bd.patch

@@ -0,0 +1,1066 @@
+diff --git a/compiler/rustc_attr_ir/src/data_structures.rs b/compiler/rustc_attr_ir/src/data_structures.rs
+index 195712559782ddd3686569b16f64493272da80cb..e6baaf28fbc6dd12029b72ffea82e8dc4ea58057 100644
+--- a/compiler/rustc_attr_ir/src/data_structures.rs
++++ b/compiler/rustc_attr_ir/src/data_structures.rs
+@@ -1422,9 +1422,6 @@ pub enum AttributeKind {
+     /// Represents `#[rustc_regions]`
+     RustcRegions,
+ 
+-    /// Represents `#[rustc_reservation_impl]`
+-    RustcReservationImpl(Symbol),
+-
+     /// Represents `#[rustc_scalable_vector(N)]`
+     RustcScalableVector {
+         /// The base multiple of lanes that are in a scalable vector, if provided. `element_count`
+diff --git a/compiler/rustc_attr_ir/src/encode_cross_crate.rs b/compiler/rustc_attr_ir/src/encode_cross_crate.rs
+index 637fbaeabdc669011b47e9e43e23cda1266828c0..164ab3c5822d058e265ccbba6746d280aea65597 100644
+--- a/compiler/rustc_attr_ir/src/encode_cross_crate.rs
++++ b/compiler/rustc_attr_ir/src/encode_cross_crate.rs
+@@ -185,7 +185,6 @@ impl AttributeKind {
+             RustcPubTransparent(..) => Yes,
+             RustcReallocator => No,
+             RustcRegions => No,
+-            RustcReservationImpl(..) => Yes,
+             RustcScalableVector { .. } => Yes,
+             RustcShouldNotBeCalledOnConstItems => Yes,
+             RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate
+diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+index f1860acc4c05a626776544bfe3d2040746147cf2..3620847a19301fdf6a71d6659cf2dba22ce1977a 100644
+--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
++++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+@@ -1122,23 +1122,6 @@ impl NoArgsAttributeParser for RustcStrictCoherenceParser {
+     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcStrictCoherence;
+ }
+ 
+-pub(crate) struct RustcReservationImplParser;
+-
+-impl SingleAttributeParser for RustcReservationImplParser {
+-    const PATH: &[Symbol] = &[sym::rustc_reservation_impl];
+-    const ALLOWED_TARGETS: AllowedTargets<'_> =
+-        AllowedTargets::AllowList(&[Allow(Target::Impl { of_trait: true })]);
+-    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "reservation message");
+-    const STABILITY: AttributeStability = unstable!(rustc_attrs);
+-
+-    fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
+-        let nv = cx.expect_name_value(args, cx.attr_span, None)?;
+-        let value_str = cx.expect_string_literal(nv)?;
+-
+-        Some(AttributeKind::RustcReservationImpl(value_str))
+-    }
+-}
+-
+ pub(crate) struct PreludeImportParser;
+ 
+ impl NoArgsAttributeParser for PreludeImportParser {
+diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
+index 5783f17028029b2610db04429c373bdac3a3bda4..7fe799a027c542db51a06eecde99fea204502924 100644
+--- a/compiler/rustc_attr_parsing/src/context.rs
++++ b/compiler/rustc_attr_parsing/src/context.rs
+@@ -249,7 +249,6 @@ attribute_parsers!(
+         Single<RustcNeverTypeOptionsParser>,
+         Single<RustcObjcClassParser>,
+         Single<RustcObjcSelectorParser>,
+-        Single<RustcReservationImplParser>,
+         Single<RustcScalableVectorParser>,
+         Single<RustcSimdMonomorphizeLaneLimitParser>,
+         Single<RustcSkipDuringMethodDispatchParser>,
+diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
+index fd68af02de6105ffae992a5215f2f2fb6ad36fbf..85a7c5aca0970ff80b3567c7e5a6ae7e9e49cf51 100644
+--- a/compiler/rustc_feature/src/builtin_attrs.rs
++++ b/compiler/rustc_feature/src/builtin_attrs.rs
+@@ -364,7 +364,6 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
+     sym::prelude_import,
+     sym::rustc_paren_sugar,
+     sym::rustc_inherit_overflow_checks,
+-    sym::rustc_reservation_impl,
+     sym::rustc_test_entrypoint_marker,
+     sym::rustc_test_marker,
+     sym::rustc_allow_lifetime_dependent_specialization,
+diff --git a/compiler/rustc_hir_analysis/src/check/always_applicable.rs b/compiler/rustc_hir_analysis/src/check/always_applicable.rs
+index 6a30ff40eedc697214d30bad35dbbd1e4344b84d..60636a11649268dceaf712ea10dbf08b428a7a5a 100644
+--- a/compiler/rustc_hir_analysis/src/check/always_applicable.rs
++++ b/compiler/rustc_hir_analysis/src/check/always_applicable.rs
+@@ -43,12 +43,7 @@ pub(crate) fn check_drop_impl(
+     match tcx.impl_polarity(drop_impl_did) {
+         ty::ImplPolarity::Positive => {}
+         ty::ImplPolarity::Negative => {
+-            return Err(tcx.dcx().emit_err(diagnostics::DropImplPolarity::Negative {
+-                span: tcx.def_span(drop_impl_did),
+-            }));
+-        }
+-        ty::ImplPolarity::Reservation => {
+-            return Err(tcx.dcx().emit_err(diagnostics::DropImplPolarity::Reservation {
++            return Err(tcx.dcx().emit_err(diagnostics::NegativeDropImplPolarity {
+                 span: tcx.def_span(drop_impl_did),
+             }));
+         }
+@@ -153,7 +148,7 @@ fn ensure_impl_params_and_item_params_correspond<'tcx>(
+     let item_span = tcx.def_span(adt_def_id);
+     let self_descr = tcx.def_descr(adt_def_id);
+     let polarity = match tcx.impl_polarity(impl_def_id) {
+-        ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => "",
++        ty::ImplPolarity::Positive => "",
+         ty::ImplPolarity::Negative => "!",
+     };
+     let trait_name = tcx.item_name(tcx.impl_trait_id(impl_def_id.to_def_id()));
+@@ -265,7 +260,7 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
+     let impl_span = tcx.def_span(impl_def_id.to_def_id());
+     let trait_name = tcx.item_name(tcx.impl_trait_id(impl_def_id.to_def_id()));
+     let polarity = match tcx.impl_polarity(impl_def_id) {
+-        ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => "",
++        ty::ImplPolarity::Positive => "",
+         ty::ImplPolarity::Negative => "!",
+     };
+     // Take the param-env of the adt and instantiate the args that show up in
+diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
+index 614d5517ba1f69c93ae767e99fb62ca90422f673..1895f586df2f09118deec451e645d9b6d518fa0d 100644
+--- a/compiler/rustc_hir_analysis/src/check/check.rs
++++ b/compiler/rustc_hir_analysis/src/check/check.rs
+@@ -1296,7 +1296,7 @@ fn check_impl_items_against_trait<'tcx>(
+ 
+     // Negative impls are not expected to have any items
+     match impl_trait_header.polarity {
+-        ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
++        ty::ImplPolarity::Positive => {}
+         ty::ImplPolarity::Negative => {
+             if let [first_item_ref, ..] = *impl_item_refs {
+                 let first_item_span = tcx.def_span(first_item_ref);
+diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+index c9324858543988f0d6b3c4ac9c36eed8e9569b16..f2dec4c7db89f8ee45dc6a7908388786c9b45acc 100644
+--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
++++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+@@ -317,9 +317,6 @@ pub(super) fn check_item<'tcx>(
+                             .emit());
+                         }
+                     }
+-                    ty::ImplPolarity::Reservation => {
+-                        // FIXME: what amount of WF checking do we need for reservation impls?
+-                    }
+                 }
+             } else {
+                 res = res.and(check_impl(tcx, item, impl_));
+@@ -1310,9 +1307,6 @@ fn check_impl<'tcx>(
+     enter_wf_checking_ctxt(tcx, item.owner_id.def_id, |wfcx| {
+         match impl_.of_trait {
+             Some(of_trait) => {
+-                // `#[rustc_reservation_impl]` impls are not real impls and
+-                // therefore don't need to be WF (the trait's `Self: Trait` predicate
+-                // won't hold).
+                 let trait_ref = tcx.impl_trait_ref(item.owner_id).instantiate_identity();
+                 // Avoid bogus "type annotations needed `Foo: Bar`" errors on `impl Bar for Foo` in
+                 // case other `Foo` impls are incoherent.
+diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+index 06d336298a42c31d153290e1ba027042bdd2e206..34a3f155baf43b8ce1ea417932ee6b7a164c9299 100644
+--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
++++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+@@ -170,7 +170,7 @@ fn visit_implementation_of_const_param_ty(checker: &Checker<'_>) -> Result<(), E
+ 
+     let param_env = tcx.param_env(impl_did);
+ 
+-    if let ty::ImplPolarity::Negative | ty::ImplPolarity::Reservation = header.polarity {
++    if let ty::ImplPolarity::Negative = header.polarity {
+         return Ok(());
+     }
+ 
+diff --git a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
+index 7fcf8ddceea5cd43b817cb584c1dc50b90de93c5..ce0171a4d2d7dd54e55dc168a89f5aa4752b104b 100644
+--- a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
++++ b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
+@@ -34,7 +34,7 @@ pub(super) fn check_item(
+     };
+ 
+     match (trait_def_safety, unsafe_attr, trait_header.safety, trait_header.polarity) {
+-        (Safety::Safe, None, Safety::Unsafe, Positive | Reservation) => {
++        (Safety::Safe, None, Safety::Unsafe, Positive) => {
+             let span = tcx.def_span(def_id);
+             return Err(struct_span_code_err!(
+                 tcx.dcx(),
+@@ -52,7 +52,7 @@ pub(super) fn check_item(
+             .emit());
+         }
+ 
+-        (Safety::Unsafe, _, Safety::Safe, Positive | Reservation) => {
++        (Safety::Unsafe, _, Safety::Safe, Positive) => {
+             let span = tcx.def_span(def_id);
+             return Err(struct_span_code_err!(
+                 tcx.dcx(),
+@@ -86,7 +86,7 @@ pub(super) fn check_item(
+             .emit());
+         }
+ 
+-        (Safety::Safe, Some(attr_name), Safety::Safe, Positive | Reservation) => {
++        (Safety::Safe, Some(attr_name), Safety::Safe, Positive) => {
+             let span = tcx.def_span(def_id);
+             return Err(struct_span_code_err!(
+                 tcx.dcx(),
+@@ -116,8 +116,8 @@ pub(super) fn check_item(
+             Ok(())
+         }
+         (_, _, Safety::Safe, Negative)
+-        | (Safety::Unsafe, _, Safety::Unsafe, Positive | Reservation)
+-        | (Safety::Safe, Some(_), Safety::Unsafe, Positive | Reservation)
++        | (Safety::Unsafe, _, Safety::Unsafe, Positive)
++        | (Safety::Safe, Some(_), Safety::Unsafe, Positive)
+         | (Safety::Safe, None, Safety::Safe, _) => Ok(()),
+     }
+ }
+diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
+index 0b58b42461319a030fe6143e10d5ca3a0d1c354d..65fd562a4ebf6d7d0397b4d14a0960f2888189bd 100644
+--- a/compiler/rustc_hir_analysis/src/collect.rs
++++ b/compiler/rustc_hir_analysis/src/collect.rs
+@@ -1549,7 +1549,6 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
+         .of_trait
+         .unwrap_or_else(|| panic!("expected impl trait, found inherent impl on {def_id:?}"));
+     let selfty = tcx.type_of(def_id).instantiate_identity().skip_norm_wip();
+-    let is_rustc_reservation = find_attr!(tcx, def_id, RustcReservationImpl(..));
+ 
+     check_impl_constness(tcx, impl_.constness, &of_trait.trait_ref);
+ 
+@@ -1558,7 +1557,7 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
+     ty::ImplTraitHeader {
+         trait_ref: ty::EarlyBinder::bind(tcx, trait_ref),
+         safety: of_trait.safety,
+-        polarity: polarity_of_impl(tcx, of_trait, is_rustc_reservation),
++        polarity: polarity_of_impl(of_trait),
+         constness: impl_.constness,
+     }
+ }
+@@ -1605,26 +1604,10 @@ fn check_impl_constness(
+     });
+ }
+ 
+-fn polarity_of_impl(
+-    tcx: TyCtxt<'_>,
+-    of_trait: &hir::TraitImplHeader<'_>,
+-    is_rustc_reservation: bool,
+-) -> ty::ImplPolarity {
++fn polarity_of_impl(of_trait: &hir::TraitImplHeader<'_>) -> ty::ImplPolarity {
+     match of_trait.polarity {
+-        hir::ImplPolarity::Negative(span) => {
+-            if is_rustc_reservation {
+-                let span = span.to(of_trait.trait_ref.path.span);
+-                tcx.dcx().span_err(span, "reservation impls can't be negative");
+-            }
+-            ty::ImplPolarity::Negative
+-        }
+-        hir::ImplPolarity::Positive => {
+-            if is_rustc_reservation {
+-                ty::ImplPolarity::Reservation
+-            } else {
+-                ty::ImplPolarity::Positive
+-            }
+-        }
++        hir::ImplPolarity::Negative(_) => ty::ImplPolarity::Negative,
++        hir::ImplPolarity::Positive => ty::ImplPolarity::Positive,
+     }
+ }
+ 
+diff --git a/compiler/rustc_hir_analysis/src/diagnostics.rs b/compiler/rustc_hir_analysis/src/diagnostics.rs
+index ef287b737851f6d513882d77f5967f6a07d274b4..a50aefd0160590155f28bdd28fd43e52360dd9d4 100644
+--- a/compiler/rustc_hir_analysis/src/diagnostics.rs
++++ b/compiler/rustc_hir_analysis/src/diagnostics.rs
+@@ -1081,17 +1081,10 @@ pub(crate) struct StaticSpecialize {
+ }
+ 
+ #[derive(Diagnostic)]
+-pub(crate) enum DropImplPolarity {
+-    #[diag("negative `Drop` impls are not supported")]
+-    Negative {
+-        #[primary_span]
+-        span: Span,
+-    },
+-    #[diag("reservation `Drop` impls are not supported")]
+-    Reservation {
+-        #[primary_span]
+-        span: Span,
+-    },
++#[diag("negative `Drop` impls are not supported")]
++pub(crate) struct NegativeDropImplPolarity {
++    #[primary_span]
++    pub span: Span,
+ }
+ 
+ #[derive(Diagnostic)]
+diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
+index c4b886110595b44e11bf1993ebe20d0d187d812d..19d86ebe7cced86e73a0c9084c8e3e77b52ca3d8 100644
+--- a/compiler/rustc_middle/src/ty/mod.rs
++++ b/compiler/rustc_middle/src/ty/mod.rs
+@@ -1905,10 +1905,6 @@ impl<'tcx> TyCtxt<'tcx> {
+         }
+ 
+         match (impl1.polarity, impl2.polarity) {
+-            (ImplPolarity::Reservation, _) | (_, ImplPolarity::Reservation) => {
+-                // `#[rustc_reservation_impl]` impls don't overlap with anything
+-                return Some(ImplOverlapKind::Permitted { marker: false });
+-            }
+             (ImplPolarity::Positive, ImplPolarity::Negative)
+             | (ImplPolarity::Negative, ImplPolarity::Positive) => {
+                 // `impl AutoTrait for Type` + `impl !AutoTrait for Type`
+diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+index a93fd853b6216ed22f1be2ed6ff10b8efddf4b6e..6980946f8fbc819fb27a87d6d3db59bf7b01784a 100644
+--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
++++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+@@ -219,7 +219,7 @@ where
+         goal: Goal<I, Self>,
+         goal_trait_ref: ty::TraitRef<I>,
+         impl_def_id: I::ImplId,
+-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
++        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
+     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased>;
+ 
+     /// If the predicate contained an error, we want to avoid emitting unnecessary trait
+@@ -553,13 +553,9 @@ where
+         let cx = self.cx();
+         let goal_trait_ref = goal.predicate.trait_ref(cx);
+         cx.for_each_relevant_impl(goal_trait_ref, |impl_def_id| -> Result<_, _> {
+-            match G::consider_impl_candidate(
+-                self,
+-                goal,
+-                goal_trait_ref,
+-                impl_def_id,
+-                |ecx, certainty| ecx.evaluate_added_goals_and_make_canonical_response(certainty),
+-            )
++            match G::consider_impl_candidate(self, goal, goal_trait_ref, impl_def_id, |ecx| {
++                ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
++            })
+             .map_err_to_rerun()?
+             {
+                 Ok(candidate) => candidates.push(candidate),
+@@ -1171,27 +1167,21 @@ where
+         if assemble_from.should_assemble_impl_candidates() {
+             let cx = self.cx();
+             let goal_trait_ref = goal.predicate.trait_ref(cx);
++
+             cx.for_each_blanket_impl(goal.predicate.trait_def_id(cx), |impl_def_id| {
+-                match G::consider_impl_candidate(
+-                    self,
+-                    goal,
+-                    goal_trait_ref,
+-                    impl_def_id,
+-                    |ecx, certainty| {
+-                        if ecx.shallow_resolve(self_ty).is_ty_var() {
+-                            // We force the certainty of impl candidates to be `Maybe`.
+-                            let certainty = certainty.and(Certainty::AMBIGUOUS);
+-                            ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+-                        } else {
+-                            // We don't want to use impls if they constrain the opaque.
+-                            //
+-                            // FIXME(trait-system-refactor-initiative#229): This isn't
+-                            // perfect yet as it still allows us to incorrectly constrain
+-                            // other inference variables.
+-                            Err(NoSolution.into())
+-                        }
+-                    },
+-                )
++                match G::consider_impl_candidate(self, goal, goal_trait_ref, impl_def_id, |ecx| {
++                    if ecx.shallow_resolve(self_ty).is_ty_var() {
++                        // We force the certainty of impl candidates to be `Maybe`.
++                        ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
++                    } else {
++                        // We don't want to use impls if they constrain the opaque.
++                        //
++                        // FIXME(trait-system-refactor-initiative#229): This isn't
++                        // perfect yet as it still allows us to incorrectly constrain
++                        // other inference variables.
++                        Err(NoSolution.into())
++                    }
++                })
+                 .map_err_to_rerun()?
+                 {
+                     Ok(candidate) => candidates.push(candidate),
+diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+index 993ce05330a29243fe21f92a1db48e249c0cbac8..04d1376d20b9f31c6f9b1ebdeb7e3f39967e1d28 100644
+--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
++++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+@@ -138,7 +138,7 @@ where
+         goal: Goal<I, Self>,
+         goal_trait_ref: ty::TraitRef<I>,
+         impl_def_id: I::ImplId,
+-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
++        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
+     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
+         let cx = ecx.cx();
+ 
+@@ -156,17 +156,9 @@ where
+             return Err(NoSolution.into());
+         }
+ 
+-        let impl_polarity = cx.impl_polarity(impl_def_id);
+-        let certainty = match impl_polarity {
++        match cx.impl_polarity(impl_def_id) {
+             ty::ImplPolarity::Negative => return Err(NoSolution.into()),
+-            ty::ImplPolarity::Reservation => {
+-                if ecx.typing_mode().is_coherence() {
+-                    Certainty::AMBIGUOUS
+-                } else {
+-                    return Err(NoSolution.into());
+-                }
+-            }
+-            ty::ImplPolarity::Positive => Certainty::Yes,
++            ty::ImplPolarity::Positive => (),
+         };
+ 
+         if !cx.impl_is_const(impl_def_id) {
+@@ -200,7 +192,7 @@ where
+                 });
+             ecx.add_goals(GoalSource::ImplWhereBound, const_conditions)?;
+ 
+-            then(ecx, certainty)
++            then(ecx)
+         })
+     }
+ 
+diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs
+index 1d8617812937ffdb2075e345f6844e32811fe044..f5b1df1be3eff72061543781046557d1177aaf1d 100644
+--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs
++++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs
+@@ -255,7 +255,7 @@ where
+         goal: Goal<I, NormalizesTo<I>>,
+         goal_trait_ref: ty::TraitRef<I>,
+         impl_def_id: I::ImplId,
+-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
++        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
+     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
+         let cx = ecx.cx();
+ 
+@@ -278,9 +278,6 @@ where
+         let impl_polarity = cx.impl_polarity(impl_def_id);
+         match impl_polarity {
+             ty::ImplPolarity::Negative => return Err(NoSolution.into()),
+-            ty::ImplPolarity::Reservation => {
+-                unimplemented!("reservation impl for trait with assoc item: {:?}", goal)
+-            }
+             ty::ImplPolarity::Positive => {}
+         };
+ 
+@@ -390,10 +387,10 @@ where
+                         // This is not the case here and we only prefer adding an ambiguous
+                         // nested goal for consistency.
+                         ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous))?;
+-                        return then(ecx, Certainty::Yes);
++                        return then(ecx);
+                     } else {
+                         ecx.instantiate_normalizes_to_as_rigid(goal)?;
+-                        return then(ecx, Certainty::Yes);
++                        return then(ecx);
+                     }
+                 } else {
+                     return error_response(ecx, cx.delay_bug("missing item"));
+diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+index 14cb3acad68e0a2ce2425d689c74dda2506c1592..902ad882f212324f72e5d73acad9d352d9829ee9 100644
+--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
++++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+@@ -62,7 +62,7 @@ where
+         goal: Goal<I, TraitClause<I>>,
+         goal_trait_ref: TraitRef<I>,
+         impl_def_id: I::ImplId,
+-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
++        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
+     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
+         let cx = ecx.cx();
+ 
+@@ -80,37 +80,21 @@ where
+             return Err(NoSolution.into());
+         }
+ 
+-        // An upper bound of the certainty of this goal, used to lower the certainty
+-        // of reservation impl to ambiguous during coherence.
+-        let impl_polarity = cx.impl_polarity(impl_def_id);
+-        let maximal_certainty = match (impl_polarity, goal.predicate.polarity) {
+-            // In coherence mode, this is ambiguous. But outside of coherence, it's not a real impl.
+-            (ty::ImplPolarity::Reservation, _) => {
+-                if ecx.typing_mode().is_coherence() {
+-                    Certainty::AMBIGUOUS
+-                } else {
+-                    return Err(NoSolution.into());
+-                }
+-            }
+-
++        match (cx.impl_polarity(impl_def_id), goal.predicate.polarity) {
+             // Impl matches polarity
+             (ty::ImplPolarity::Positive, ty::ClausePolarity::Positive)
+-            | (ty::ImplPolarity::Negative, ty::ClausePolarity::Negative) => {
+-                if ecx.typing_mode().is_reflection()
+-                    && !cx.is_fully_generic_for_reflection(impl_def_id)
+-                {
+-                    return Err(NoSolution.into());
+-                } else {
+-                    Certainty::Yes
+-                }
+-            }
++            | (ty::ImplPolarity::Negative, ty::ClausePolarity::Negative) => {}
+ 
+             // Impl doesn't match polarity
+             (ty::ImplPolarity::Positive, ty::ClausePolarity::Negative)
+             | (ty::ImplPolarity::Negative, ty::ClausePolarity::Positive) => {
+                 return Err(NoSolution.into());
+             }
+-        };
++        }
++
++        if ecx.typing_mode().is_reflection() && !cx.is_fully_generic_for_reflection(impl_def_id) {
++            return Err(NoSolution.into());
++        }
+ 
+         ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
+             let impl_args = ecx.fresh_args_for_item(impl_def_id.into());
+@@ -136,7 +120,7 @@ where
+                     .map(|pred| goal.with(cx, pred)),
+             )?;
+ 
+-            then(ecx, maximal_certainty)
++            then(ecx)
+         })
+     }
+ 
+diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
+index 7f9e4fc553455cffaa4d4a1aecfed8916a4aa90e..a483e3f0fe8c112640b2b665aac6c986e6371050 100644
+--- a/compiler/rustc_passes/src/check_attr.rs
++++ b/compiler/rustc_passes/src/check_attr.rs
+@@ -391,7 +391,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
+             AttributeKind::RustcPubTransparent(..) => (),
+             AttributeKind::RustcReallocator => (),
+             AttributeKind::RustcRegions => (),
+-            AttributeKind::RustcReservationImpl(..) => (),
+             AttributeKind::RustcScalableVector { .. } => (),
+             AttributeKind::RustcShouldNotBeCalledOnConstItems => (),
+             AttributeKind::RustcSimdMonomorphizeLaneLimit(..) => (),
+diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+index 9eed22dc15d05f7fb223e6a1140050477a37046f..da5766fba87db4cf11a064b1a8131f1ca2340210 100644
+--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
++++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+@@ -896,7 +896,6 @@ impl<'tcx> Stable<'tcx> for ty::ImplPolarity {
+         match self {
+             Positive => crate::ty::ImplPolarity::Positive,
+             Negative => crate::ty::ImplPolarity::Negative,
+-            Reservation => crate::ty::ImplPolarity::Reservation,
+         }
+     }
+ }
+diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
+index e8333751d1df81851e3fe7aad354756c6247b6f8..6376fe032c64e0212b3c3b8fffd0356683ca284b 100644
+--- a/compiler/rustc_span/src/symbol.rs
++++ b/compiler/rustc_span/src/symbol.rs
+@@ -1871,7 +1871,6 @@ symbols! {
+         rustc_pub_transparent,
+         rustc_reallocator,
+         rustc_regions,
+-        rustc_reservation_impl,
+         rustc_scalable_vector,
+         rustc_should_not_be_called_on_const_items,
+         rustc_simd_monomorphize_lane_limit,
+diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
+index ec854e25a6aa2fa41c1182618c916485beb410ca..24217aaf75fe7b817b0f140505ad8563d1bf3bef 100644
+--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
++++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
+@@ -9,7 +9,6 @@ use std::fmt::Debug;
+ use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
+ use rustc_errors::{Diag, EmissionGuarantee};
+ use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
+-use rustc_hir::find_attr;
+ use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
+ use rustc_infer::traits::{PredicateObligations, TraitErrors};
+ use rustc_macros::{TypeFoldable, TypeVisitable};
+@@ -767,20 +766,6 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a, 'tcx> {
+         }
+ 
+         let mut candidates = goal.candidates();
+-        for cand in goal.candidates() {
+-            if let inspect::ProbeKind::TraitCandidate {
+-                source: CandidateSource::Impl(def_id),
+-                result: Ok(_),
+-            } = cand.kind()
+-                && let ty::ImplPolarity::Reservation = infcx.tcx.impl_polarity(def_id)
+-            {
+-                if let Some(message) =
+-                    find_attr!(infcx.tcx, def_id, RustcReservationImpl(message) => *message)
+-                {
+-                    self.causes.insert(IntercrateAmbiguityCause::ReservationImpl { message });
+-                }
+-            }
+-        }
+ 
+         // We also look for unknowable candidates. In case a goal is unknowable, there's
+         // always exactly 1 candidate.
+diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
+index f936e0bf072798eb3c153de44bcf58704c87366c..118616570661ecc3c9aee695c20601ed45df8d7a 100644
+--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
++++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
+@@ -10,9 +10,9 @@ use std::ops::ControlFlow;
+ use hir::def::DefKind;
+ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
+ use rustc_errors::{Diag, EmissionGuarantee};
++use rustc_hir as hir;
+ use rustc_hir::attrs::lang_items::LangItem;
+ use rustc_hir::def_id::DefId;
+-use rustc_hir::{self as hir, find_attr};
+ use rustc_infer::infer::BoundRegionConversionTime::{self, HigherRankedType};
+ use rustc_infer::infer::DefineOpaqueTypes;
+ use rustc_infer::infer::at::ToTrace;
+@@ -31,7 +31,6 @@ use rustc_middle::ty::{
+     Unnormalized, Upcast, elaborate, may_use_unstable_feature,
+ };
+ use rustc_next_trait_solver::solve::AliasBoundKind;
+-use rustc_span::Symbol;
+ use tracing::{debug, instrument, trace};
+ 
+ use self::EvaluationResult::*;
+@@ -59,7 +58,6 @@ mod confirmation;
+ pub enum IntercrateAmbiguityCause<'tcx> {
+     DownstreamCrate { trait_ref: ty::TraitRef<'tcx>, self_ty: Option<Ty<'tcx>> },
+     UpstreamCrateUpdate { trait_ref: ty::TraitRef<'tcx>, self_ty: Option<Ty<'tcx>> },
+-    ReservationImpl { message: Symbol },
+ }
+ 
+ impl<'tcx> IntercrateAmbiguityCause<'tcx> {
+@@ -94,7 +92,6 @@ impl<'tcx> IntercrateAmbiguityCause<'tcx> {
+                     }
+                 )
+             }
+-            IntercrateAmbiguityCause::ReservationImpl { message } => message.to_string(),
+         })
+     }
+ }
+@@ -441,7 +438,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
+         // Instead, we select the right impl now but report "`Bar` does
+         // not implement `Clone`".
+         if candidates.len() == 1 {
+-            return self.filter_reservation_impls(candidates.pop().unwrap());
++            return Ok(candidates.pop());
+         }
+ 
+         // Winnow, but record the exact outcome of evaluation, which
+@@ -488,13 +485,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
+             let has_non_region_infer = stack.obligation.predicate.has_non_region_infer();
+             let candidate_preference_mode =
+                 CandidatePreferenceMode::compute(self.tcx(), stack.obligation.predicate.def_id());
+-            if let Some(candidate) =
+-                self.winnow_candidates(has_non_region_infer, candidate_preference_mode, candidates)
+-            {
+-                self.filter_reservation_impls(candidate)
+-            } else {
+-                Ok(None)
+-            }
++            Ok(self.winnow_candidates(has_non_region_infer, candidate_preference_mode, candidates))
+         }
+     }
+ 
+@@ -1417,58 +1408,28 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
+     #[instrument(level = "debug", skip(self, candidates))]
+     fn filter_impls(
+         &mut self,
+-        candidates: Vec<SelectionCandidate<'tcx>>,
++        mut candidates: Vec<SelectionCandidate<'tcx>>,
+         obligation: &PolyTraitObligation<'tcx>,
+     ) -> Vec<SelectionCandidate<'tcx>> {
+         trace!("{candidates:#?}");
+         let tcx = self.tcx();
+-        let mut result = Vec::with_capacity(candidates.len());
+ 
+-        for candidate in candidates {
+-            if let ImplCandidate(def_id) = candidate {
++        candidates.retain(|candidate| {
++            if let &ImplCandidate(def_id) = candidate {
+                 match (tcx.impl_polarity(def_id), obligation.polarity()) {
+-                    (ty::ImplPolarity::Reservation, _)
+-                    | (ty::ImplPolarity::Positive, ty::ClausePolarity::Positive)
+-                    | (ty::ImplPolarity::Negative, ty::ClausePolarity::Negative) => {
+-                        result.push(candidate);
+-                    }
+-                    _ => {}
++                    (ty::ImplPolarity::Positive, ty::ClausePolarity::Positive)
++                    | (ty::ImplPolarity::Negative, ty::ClausePolarity::Negative) => true,
++
++                    // remove impl candidates with mismatched polarity to the obligation
++                    _ => false,
+                 }
+             } else {
+-                result.push(candidate);
++                true
+             }
+-        }
+-
+-        trace!("{result:#?}");
+-        result
+-    }
++        });
+ 
+-    /// filter_reservation_impls filter reservation impl for any goal as ambiguous
+-    #[instrument(level = "debug", skip(self))]
+-    fn filter_reservation_impls(
+-        &mut self,
+-        candidate: SelectionCandidate<'tcx>,
+-    ) -> SelectionResult<'tcx, SelectionCandidate<'tcx>> {
+-        let tcx = self.tcx();
+-        // Treat reservation impls as ambiguity.
+-        if let ImplCandidate(def_id) = candidate
+-            && let ty::ImplPolarity::Reservation = tcx.impl_polarity(def_id)
+-        {
+-            if let Some(intercrate_ambiguity_clauses) = &mut self.intercrate_ambiguity_causes {
+-                let message = find_attr!(tcx, def_id, RustcReservationImpl(message) => *message);
+-                if let Some(message) = message {
+-                    debug!(
+-                        "filter_reservation_impls: \
+-                                 reservation impl ambiguity on {:?}",
+-                        def_id
+-                    );
+-                    intercrate_ambiguity_clauses
+-                        .insert(IntercrateAmbiguityCause::ReservationImpl { message });
+-                }
+-            }
+-            return Ok(None);
+-        }
+-        Ok(Some(candidate))
++        trace!("{candidates:#?}");
++        candidates
+     }
+ 
+     fn is_knowable<'o>(&mut self, stack: &TraitObligationStack<'o, 'tcx>) -> Result<(), Conflict> {
+@@ -2560,7 +2521,6 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
+         nested_obligations.extend(obligations);
+ 
+         match self.typing_mode() {
+-            TypingMode::Coherence => {}
+             TypingMode::Reflection
+                 if !self.tcx().impl_is_fully_generic_for_reflection(impl_def_id) =>
+             {
+@@ -2568,18 +2528,14 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
+                 return Err(());
+             }
+ 
+-            TypingMode::Typeck { .. }
++            TypingMode::Coherence
++            | TypingMode::Typeck { .. }
+             | TypingMode::PostTypeckUntilBorrowck { .. }
+             | TypingMode::PostBorrowck { .. }
+             | TypingMode::Codegen
+             | TypingMode::ErasedNotCoherence(_)
+             | TypingMode::Reflection
+-            | TypingMode::PostAnalysis => {
+-                if impl_trait_header.polarity == ty::ImplPolarity::Reservation {
+-                    debug!("reservation impls only apply in intercrate mode");
+-                    return Err(());
+-                }
+-            }
++            | TypingMode::PostAnalysis => {}
+         }
+ 
+         Ok(Normalized { value: impl_args, obligations: nested_obligations })
+diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
+index a819530485ccd196aca3da8a0cc12aeb196295a1..7d281663d50338cad4b6d807a2b107c28a61254c 100644
+--- a/compiler/rustc_type_ir/src/predicate.rs
++++ b/compiler/rustc_type_ir/src/predicate.rs
+@@ -265,11 +265,6 @@ pub enum ImplPolarity {
+     Positive,
+     /// `impl !Trait for Type`
+     Negative,
+-    /// `#[rustc_reservation_impl] impl Trait for Type`
+-    ///
+-    /// This is a "stability hack", not a real Rust feature.
+-    /// See #64631 for details.
+-    Reservation,
+ }
+ 
+ impl fmt::Display for ImplPolarity {
+@@ -277,7 +272,6 @@ impl fmt::Display for ImplPolarity {
+         match self {
+             Self::Positive => f.write_str("positive"),
+             Self::Negative => f.write_str("negative"),
+-            Self::Reservation => f.write_str("reservation"),
+         }
+     }
+ }
+@@ -288,7 +282,6 @@ impl ImplPolarity {
+         match self {
+             Self::Positive => "",
+             Self::Negative => "!",
+-            Self::Reservation => "",
+         }
+     }
+ }
+diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
+index eddf3e4873039ae41c994e2979ddf83e044fde31..a9ecf6d66d001bc1a987983cfd3ca14a61cee07f 100644
+--- a/src/librustdoc/html/render/mod.rs
++++ b/src/librustdoc/html/render/mod.rs
+@@ -948,7 +948,7 @@ fn short_item_info(
+ fn impl_trait_key(cx: &Context<'_>, i: &Impl) -> Option<String> {
+     let trait_ = i.inner_impl().trait_.as_ref()?;
+     let prefix = match i.inner_impl().polarity {
+-        ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => "",
++        ty::ImplPolarity::Positive => "",
+         ty::ImplPolarity::Negative => "!",
+     };
+     Some(format!("{prefix}{:#}", print_path(trait_, cx)))
+@@ -964,7 +964,7 @@ fn render_impls<'a, 'cx>(
+ ) -> impl fmt::Display + use<'a, 'cx> {
+     impls.sort_by_cached_key(|imp| {
+         let prefix = match imp.inner_impl().polarity {
+-            ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => Ordering::Greater,
++            ty::ImplPolarity::Positive => Ordering::Greater,
+             ty::ImplPolarity::Negative => Ordering::Less,
+         };
+         (prefix, ImplString::new_path(imp, cx))
+diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
+index b19ed533d49531a21c450618fae00e519ce800df..5a0e9d9e810e7cce7b4a99abcc4b929943fa5f2b 100644
+--- a/src/librustdoc/json/conversions.rs
++++ b/src/librustdoc/json/conversions.rs
+@@ -829,7 +829,7 @@ impl FromClean<clean::Impl> for Impl {
+             clean::ImplKind::Blanket(ty) => (false, Some(ty)),
+         };
+         let is_negative = match polarity {
+-            ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => false,
++            ty::ImplPolarity::Positive => false,
+             ty::ImplPolarity::Negative => true,
+         };
+         Impl {
+diff --git a/tests/ui/dropck/reservation.rs b/tests/ui/dropck/reservation.rs
+deleted file mode 100644
+index f7199d4ec44074d63c02aaf3e228e9f31f2746ea..0000000000000000000000000000000000000000
+--- a/tests/ui/dropck/reservation.rs
++++ /dev/null
+@@ -1,10 +0,0 @@
+-#![feature(rustc_attrs)]
+-
+-struct ReservedDrop;
+-#[rustc_reservation_impl = "message"]
+-impl Drop for ReservedDrop {
+-//~^ ERROR reservation `Drop` impls are not supported
+-    fn drop(&mut self) {}
+-}
+-
+-fn main() {}
+diff --git a/tests/ui/dropck/reservation.stderr b/tests/ui/dropck/reservation.stderr
+deleted file mode 100644
+index a6ebf158a075d49ea8a289c1940e87fb1e0acb48..0000000000000000000000000000000000000000
+--- a/tests/ui/dropck/reservation.stderr
++++ /dev/null
+@@ -1,8 +0,0 @@
+-error: reservation `Drop` impls are not supported
+-  --> $DIR/reservation.rs:5:1
+-   |
+-LL | impl Drop for ReservedDrop {
+-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+-
+-error: aborting due to 1 previous error
+-
+diff --git a/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr b/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr
+deleted file mode 100644
+index 2b5277f93328955f080294b0fa20028c0b8f8f9e..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr
++++ /dev/null
+@@ -1,13 +0,0 @@
+-error[E0119]: conflicting implementations of trait `OtherTrait` for type `()`
+-  --> $DIR/coherence-conflict.rs:12:1
+-   |
+-LL | impl OtherTrait for () {}
+-   | ---------------------- first implementation here
+-LL | impl<T: MyTrait> OtherTrait for T {}
+-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `()`
+-   |
+-   = note: this impl is reserved
+-
+-error: aborting due to 1 previous error
+-
+-For more information about this error, try `rustc --explain E0119`.
+diff --git a/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr b/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr
+deleted file mode 100644
+index 2b5277f93328955f080294b0fa20028c0b8f8f9e..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr
++++ /dev/null
+@@ -1,13 +0,0 @@
+-error[E0119]: conflicting implementations of trait `OtherTrait` for type `()`
+-  --> $DIR/coherence-conflict.rs:12:1
+-   |
+-LL | impl OtherTrait for () {}
+-   | ---------------------- first implementation here
+-LL | impl<T: MyTrait> OtherTrait for T {}
+-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `()`
+-   |
+-   = note: this impl is reserved
+-
+-error: aborting due to 1 previous error
+-
+-For more information about this error, try `rustc --explain E0119`.
+diff --git a/tests/ui/traits/reservation-impl/coherence-conflict.rs b/tests/ui/traits/reservation-impl/coherence-conflict.rs
+deleted file mode 100644
+index 558793c25f3c44788863088989e6451640609875..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/coherence-conflict.rs
++++ /dev/null
+@@ -1,15 +0,0 @@
+-// check that reservation impls are accounted for in negative reasoning.
+-//@ revisions: old next
+-//@[next] compile-flags: -Znext-solver
+-#![feature(rustc_attrs)]
+-
+-trait MyTrait {}
+-#[rustc_reservation_impl="this impl is reserved"]
+-impl MyTrait for () {}
+-
+-trait OtherTrait {}
+-impl OtherTrait for () {}
+-impl<T: MyTrait> OtherTrait for T {}
+-//~^ ERROR conflicting implementations
+-
+-fn main() {}
+diff --git a/tests/ui/traits/reservation-impl/no-use.next.stderr b/tests/ui/traits/reservation-impl/no-use.next.stderr
+deleted file mode 100644
+index 772e360eade443a010488aa90f3535b20989fd2d..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/no-use.next.stderr
++++ /dev/null
+@@ -1,9 +0,0 @@
+-error[E0277]: the trait bound `(): MyTrait` is not satisfied
+-  --> $DIR/no-use.rs:11:6
+-   |
+-LL |     <() as MyTrait>::foo(&());
+-   |      ^^ the trait `MyTrait` is not implemented for `()`
+-
+-error: aborting due to 1 previous error
+-
+-For more information about this error, try `rustc --explain E0277`.
+diff --git a/tests/ui/traits/reservation-impl/no-use.old.stderr b/tests/ui/traits/reservation-impl/no-use.old.stderr
+deleted file mode 100644
+index 772e360eade443a010488aa90f3535b20989fd2d..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/no-use.old.stderr
++++ /dev/null
+@@ -1,9 +0,0 @@
+-error[E0277]: the trait bound `(): MyTrait` is not satisfied
+-  --> $DIR/no-use.rs:11:6
+-   |
+-LL |     <() as MyTrait>::foo(&());
+-   |      ^^ the trait `MyTrait` is not implemented for `()`
+-
+-error: aborting due to 1 previous error
+-
+-For more information about this error, try `rustc --explain E0277`.
+diff --git a/tests/ui/traits/reservation-impl/no-use.rs b/tests/ui/traits/reservation-impl/no-use.rs
+deleted file mode 100644
+index b470a2815c0c7b77668cbc695dd019f7199ccd15..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/no-use.rs
++++ /dev/null
+@@ -1,13 +0,0 @@
+-// check that reservation impls can't be used as normal impls in positive reasoning.
+-//@ revisions: old next
+-//@[next] compile-flags: -Znext-solver
+-#![feature(rustc_attrs)]
+-
+-trait MyTrait { fn foo(&self); }
+-#[rustc_reservation_impl = "foo"]
+-impl MyTrait for () { fn foo(&self) {} }
+-
+-fn main() {
+-    <() as MyTrait>::foo(&());
+-    //~^ ERROR the trait bound `(): MyTrait` is not satisfied
+-}
+diff --git a/tests/ui/traits/reservation-impl/non-lattice-ok.rs b/tests/ui/traits/reservation-impl/non-lattice-ok.rs
+deleted file mode 100644
+index 93dab111891c079f589cfc174f0fea642ceba75a..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/non-lattice-ok.rs
++++ /dev/null
+@@ -1,70 +0,0 @@
+-//@ build-pass
+-
+-// Check that a reservation impl does not force other impls to follow
+-// a lattice discipline.
+-
+-// Why did we ever want to do this?
+-//
+-// We want to eventually add an `impl<T> From<!> for T` impl. That impl conflicts
+-// with existing impls - at least the `impl<T> From<T> for T` impl. There are
+-// 2 ways we thought of for dealing with that conflict:
+-//
+-// 1. Using specialization and doing some handling for the
+-// overlap. The current thought is to require ["intersection
+-// impls"][ii], specialization", which means providing an
+-// (higher-priority) impl for the intersection of every 2 conflicting
+-// impls that determines what happens in the intersection case. That's
+-// the first thing we thought about - see e.g.
+-// https://github.com/rust-lang/rust/issues/57012#issuecomment-452150775
+-//
+-// 2. The other way is to notice that `impl From<!> for T` is basically a
+-// marker trait since its only method is uninhabited, and allow for "marker
+-// trait overlap", where the conflict "doesn't matter" because it can't
+-// actually cause any ambiguity.
+-//
+-// Now it turned out lattice specialization doesn't work it, because an
+-// `impl<T> From<T> for Smaht<T>` would require an `impl From<!> for Smaht<!>`,
+-// breaking backwards-compatibility in a fairly painful way. So if we want to
+-// go with a known approach, we should go with a "marker trait overlap"-style
+-// approach.
+-//
+-// [ii]: https://smallcultfollowing.com/babysteps/blog/2016/09/24/intersection-impls/
+-
+-// check that reservation impls can't be used as normal impls in positive reasoning.
+-
+-//@ revisions: old next
+-//@[next] compile-flags: -Znext-solver
+-
+-#![feature(rustc_attrs)]
+-
+-trait MyTrait {}
+-
+-impl MyTrait for ! {}
+-
+-trait MyFrom<T> {
+-    fn my_from(x: T) -> Self;
+-}
+-
+-// Given the "normal" impls for From
+-#[rustc_reservation_impl = "this impl is reserved"]
+-impl<T> MyFrom<!> for T {
+-    fn my_from(x: !) -> Self {
+-        match x {}
+-    }
+-}
+-
+-impl<T> MyFrom<T> for T {
+-    fn my_from(x: T) -> Self {
+-        x
+-    }
+-}
+-
+-// ... we *do* want to allow this common pattern, of `From<!> for MySmaht<T>`
+-struct MySmaht<T>(T);
+-impl<T> MyFrom<T> for MySmaht<T> {
+-    fn my_from(x: T) -> Self {
+-        MySmaht(x)
+-    }
+-}
+-
+-fn main() {}
+diff --git a/tests/ui/traits/reservation-impl/ok.rs b/tests/ui/traits/reservation-impl/ok.rs
+deleted file mode 100644
+index cf68c1b2e96dcca904e73306ad332700a9cdc850..0000000000000000000000000000000000000000
+--- a/tests/ui/traits/reservation-impl/ok.rs
++++ /dev/null
+@@ -1,31 +0,0 @@
+-//@ run-pass
+-
+-// rpass test for reservation impls. Not 100% required because `From` uses them,
+-// but still.
+-
+-//@ revisions: old next
+-//@[next] compile-flags: -Znext-solver
+-
+-#![feature(rustc_attrs)]
+-
+-use std::mem;
+-
+-trait MyTrait<S> {
+-    fn foo(&self, s: S) -> usize;
+-}
+-
+-#[rustc_reservation_impl = "foo"]
+-impl<T> MyTrait<u64> for T {
+-    fn foo(&self, _x: u64) -> usize { 0 }
+-}
+-
+-// reservation impls don't create coherence conflicts, even with
+-// non-chain overlap.
+-impl<S> MyTrait<S> for u32 {
+-    fn foo(&self, _x: S) -> usize { mem::size_of::<S>() }
+-}
+-
+-fn main() {
+-    // ...and the non-reservation impl gets picked.XS
+-    assert_eq!(0u32.foo(0u64), mem::size_of::<u64>());
+-}

patches/20261028T105419Z/rust-lang--rust-part011/96e2d460b640d06767d7f7d0251f4620a8bad123.patch

@@ -0,0 +1,442 @@
+diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
+index 59013ca820d9c2b95454ed58c7b6dc8a0a1c9708..9307fb41b6ea5a57aab7fba604d6ca78189c0db0 100644
+--- a/clippy_dev/src/edit_lints.rs
++++ b/clippy_dev/src/edit_lints.rs
+@@ -330,11 +330,9 @@ fn uplift_update_fn<'a>(
+         let mut copy_pos = 0u32;
+         let mut changed = false;
+         let mut cursor = Cursor::new(src);
+-        while let Some(ident) = cursor.find_any_ident() {
++        while let Some(ident) = cursor.find_capture_ident() {
+             match cursor.get_text(ident) {
+-                "mod"
+-                    if remove_mod && cursor.match_ident(old_name).is_some() && cursor.match_pat(cursor::Pat::Semi) =>
+-                {
++                "mod" if remove_mod && cursor.eat_ident(old_name) && cursor.eat_semi() => {
+                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
+                     dst.push_str(new_name);
+                     copy_pos = cursor.pos();
+@@ -343,7 +341,7 @@ fn uplift_update_fn<'a>(
+                     }
+                     changed = true;
+                 },
+-                "clippy" if cursor.match_pat(cursor::Pat::DoubleColon) && cursor.match_ident(old_name).is_some() => {
++                "clippy" if cursor.eat_double_colon() && cursor.eat_ident(old_name) => {
+                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
+                     dst.push_str(new_name);
+                     copy_pos = cursor.pos();
+@@ -393,8 +391,11 @@ fn rename_update_fn<'a>(
+                         },
+                         // mod lint_name
+                         "mod" => {
+-                            if rename_mod && let Some(pos) = cursor.match_ident(old_name) {
+-                                dst.push_str(&src[copy_pos as usize..pos as usize]);
++                            if rename_mod
++                                && let Some(mod_name) = cursor.capture_ident()
++                                && cursor.get_text(mod_name) == old_name
++                            {
++                                dst.push_str(&src[copy_pos as usize..mod_name.pos as usize]);
+                                 dst.push_str(new_name);
+                                 copy_pos = cursor.pos();
+                                 changed = true;
+@@ -403,7 +404,7 @@ fn rename_update_fn<'a>(
+                         // lint_name::
+                         name if rename_mod && name == old_name => {
+                             let name_end = cursor.pos();
+-                            if cursor.match_pat(cursor::Pat::DoubleColon) {
++                            if cursor.eat_double_colon() {
+                                 dst.push_str(&src[copy_pos as usize..match_start as usize]);
+                                 dst.push_str(new_name);
+                                 copy_pos = name_end;
+diff --git a/clippy_dev/src/generate.rs b/clippy_dev/src/generate.rs
+index 4d86da4ada58065cb461dd1f886771daf056da86..2159900d580c81c869600035554ffb0ff0c94e54 100644
+--- a/clippy_dev/src/generate.rs
++++ b/clippy_dev/src/generate.rs
+@@ -73,8 +73,7 @@ impl LintData<'_> {
+             &mut |_, src, dst| {
+                 let mut cursor = Cursor::new(src);
+                 assert!(
+-                    cursor.find_ident("declare_with_version").is_some()
+-                        && cursor.find_ident("declare_with_version").is_some(),
++                    cursor.find_ident("declare_with_version") && cursor.find_ident("declare_with_version"),
+                     "error reading deprecated lints"
+                 );
+                 dst.push_str(&src[..cursor.pos() as usize]);
+diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
+index 70783118efedf4a9d4a09156c74b9f7c32dc1aa5..5c15839cd3ddf9f6687699bb8e58621b5baab3c6 100644
+--- a/clippy_dev/src/lib.rs
++++ b/clippy_dev/src/lib.rs
+@@ -1,5 +1,6 @@
+ #![feature(
+     exit_status_error,
++    macro_metavar_expr_concat,
+     new_range,
+     os_str_slice,
+     os_string_truncate,
+diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
+index 6c9594072c9b433c6156439761a772f4e173980a..78eaabbb794e877510be7210cb98078234515d65 100644
+--- a/clippy_dev/src/new_lint.rs
++++ b/clippy_dev/src/new_lint.rs
+@@ -529,9 +529,9 @@ fn parse_mod_file(path: &Path, contents: &str) -> (&'static str, usize) {
+     let mut decl_end = None;
+     let mut cursor = Cursor::new(contents);
+     let mut captures = [Capture::EMPTY];
+-    while let Some(name) = cursor.find_any_ident() {
++    while let Some(name) = cursor.find_capture_ident() {
+         match cursor.get_text(name) {
+-            "declare_clippy_lint" if cursor.match_all(&[Bang, OpenBrace], &mut []) && cursor.find_pat(CloseBrace) => {
++            "declare_clippy_lint" if cursor.match_all(&[Bang, OpenBrace], &mut []) && cursor.find_close_brace() => {
+                 decl_end = Some(cursor.pos());
+             },
+             "impl" if cursor.match_all(&[Lt, Lifetime, Gt, CaptureIdent], &mut captures) => {
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index 2bc30b61d346a0d5237e710cc99b1bb265266635..6010da42c19bb90964f21d3f99d4be9556d0c868 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -364,11 +364,11 @@ impl<'cx> ParseCxImpl<'cx> {
+ 
+         let mut cursor = Cursor::new(&file.contents);
+         let mut captures = [Capture::EMPTY; 3];
+-        while let Some(mac_name) = cursor.find_any_ident() {
++        while let Some(mac_name) = cursor.find_capture_ident() {
+             captures[1] = Capture::EMPTY;
+             match cursor.get_text(mac_name) {
+                 "declare_clippy_lint"
+-                    if cursor.match_all(LINT_DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) =>
++                    if cursor.match_all(LINT_DECL_TOKENS, &mut captures) && cursor.find_close_brace() =>
+                 {
+                     assert!(
+                         data.lints
+@@ -401,14 +401,14 @@ impl<'cx> ParseCxImpl<'cx> {
+                     let lints = self.str_list_buf.with(|buf| {
+                         // Parses a comma separated list of paths and converts each path
+                         // to a string with whitespace removed.
+-                        while !cursor.match_pat(CloseBracket) {
++                        while !cursor.eat_close_bracket() {
+                             buf.push(self.str_buf.with(|buf| {
+-                                if cursor.match_pat(DoubleColon) {
++                                if cursor.eat_double_colon() {
+                                     buf.push_str("::");
+                                 }
+                                 let capture = cursor.capture_ident()?;
+                                 buf.push_str(cursor.get_text(capture));
+-                                while cursor.match_pat(DoubleColon) {
++                                while cursor.eat_double_colon() {
+                                     buf.push_str("::");
+                                     let capture = cursor.capture_ident()?;
+                                     buf.push_str(cursor.get_text(capture));
+@@ -416,8 +416,8 @@ impl<'cx> ParseCxImpl<'cx> {
+                                 Some(self.arena.alloc_str(buf))
+                             })?);
+ 
+-                            if !cursor.match_pat(Comma) {
+-                                if !cursor.match_pat(CloseBracket) {
++                            if !cursor.eat_comma() {
++                                if !cursor.eat_close_bracket() {
+                                     return None;
+                                 }
+                                 break;
+@@ -482,11 +482,11 @@ impl<'cx> ParseCxImpl<'cx> {
+ 
+         // First instance is the macro definition.
+         assert!(
+-            cursor.find_ident("declare_with_version").is_some(),
++            cursor.find_ident("declare_with_version"),
+             "error reading deprecated lints"
+         );
+ 
+-        if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
++        if cursor.find_ident("declare_with_version") && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
+             while cursor.match_all(DECL_TOKENS, &mut captures) {
+                 assert!(
+                     data.lints
+@@ -504,7 +504,7 @@ impl<'cx> ParseCxImpl<'cx> {
+             panic!("error reading deprecated lints");
+         }
+ 
+-        if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(RENAMED_TOKENS, &mut []) {
++        if cursor.find_ident("declare_with_version") && cursor.match_all(RENAMED_TOKENS, &mut []) {
+             while cursor.match_all(DECL_TOKENS, &mut captures) {
+                 assert!(
+                     data.lints
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index c7ad710f8d20987f68877db73ad9b10796c698ae..2fffaa201582a192b55ffe8e833cf348a254f99c 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -16,7 +16,6 @@ pub enum Pat {
+     CaptureLifetime,
+     CaptureLitStr,
+     Bang,
+-    CloseBrace,
+     CloseBracket,
+     CloseParen,
+     Comma,
+@@ -126,12 +125,6 @@ impl<'txt> Cursor<'txt> {
+         self.pos
+     }
+ 
+-    /// Gets whether the cursor has exhausted its input.
+-    #[must_use]
+-    pub fn at_end(&self) -> bool {
+-        self.next_token.kind == TokenKind::Eof
+-    }
+-
+     /// Advances the cursor to the next token. If the stream is exhausted this will set
+     /// the next token to [`TokenKind::Eof`].
+     pub fn step(&mut self) {
+@@ -154,8 +147,10 @@ impl<'txt> Cursor<'txt> {
+                     Pat::AnyComments,
+                     TokenKind::BlockComment { terminated: true, .. } | TokenKind::LineComment { .. },
+                 ) => self.step(),
++                (Pat::AnyComments, _) => return true,
++
++                (Pat::Ident(x), TokenKind::Ident) if x.as_str() == self.peek_text() => break,
+                 (Pat::Bang, TokenKind::Bang)
+-                | (Pat::CloseBrace, TokenKind::CloseBrace)
+                 | (Pat::CloseBracket, TokenKind::CloseBracket)
+                 | (Pat::CloseParen, TokenKind::CloseParen)
+                 | (Pat::Comma, TokenKind::Comma)
+@@ -174,30 +169,17 @@ impl<'txt> Cursor<'txt> {
+                         kind: LiteralKind::Str { terminated: true } | LiteralKind::RawStr { .. },
+                         ..
+                     },
+-                ) => {
+-                    self.step();
+-                    return true;
+-                },
+-                (Pat::Ident(x), TokenKind::Ident) if x.as_str() == self.peek_text() => {
+-                    self.step();
+-                    return true;
+-                },
+-                (Pat::DoubleColon, TokenKind::Colon) => {
++                ) => break,
++
++                (Pat::DoubleColon, TokenKind::Colon) if self.inner.as_str().starts_with(':') => {
+                     self.step();
+-                    if matches!(self.next_token.kind, TokenKind::Colon) {
+-                        self.step();
+-                        return true;
+-                    }
+-                    return false;
++                    break;
+                 },
+-                (Pat::FatArrow, TokenKind::Eq) => {
++                (Pat::FatArrow, TokenKind::Eq) if self.inner.as_str().starts_with('>') => {
+                     self.step();
+-                    if matches!(self.next_token.kind, TokenKind::Gt) {
+-                        self.step();
+-                        return true;
+-                    }
+-                    return false;
++                    break;
+                 },
++
+                 #[rustfmt::skip]
+                 (
+                     Pat::CaptureLitStr,
+@@ -214,6 +196,7 @@ impl<'txt> Cursor<'txt> {
+                     self.step();
+                     return true;
+                 },
++
+                 (Pat::CaptureDocLines, TokenKind::LineComment { doc_style: Some(_) }) => {
+                     let pos = self.pos;
+                     loop {
+@@ -231,43 +214,26 @@ impl<'txt> Cursor<'txt> {
+                     };
+                     return true;
+                 },
++
+                 (Pat::CaptureDocLines, _) => {
+                     *captures.next().unwrap() = Capture::EMPTY;
+                     return true;
+                 },
+-                (Pat::AnyComments, _) => return true,
+                 _ => return false,
+             }
+         }
+-    }
+ 
+-    /// Consumes all tokens until the specified identifier is found and returns its
+-    /// position. Returns `None` if the identifier could not be found.
+-    ///
+-    /// The cursor will be positioned immediately after the identifier, or at the end if
+-    /// it is not.
+-    pub fn find_ident(&mut self, ident: &str) -> Option<u32> {
+-        loop {
+-            match self.next_token.kind {
+-                TokenKind::Ident if self.peek_text() == ident => {
+-                    let pos = self.pos;
+-                    self.step();
+-                    return Some(pos);
+-                },
+-                TokenKind::Eof => return None,
+-                _ => self.step(),
+-            }
+-        }
++        self.step();
++        true
+     }
+ 
+-    /// Consumes all tokens until the next identifier is found and captures it. Returns
+-    /// `None` if no identifier could be found.
+-    ///
+-    /// The cursor will be positioned immediately after the identifier, or at the end if
+-    /// it is not.
+-    pub fn find_any_ident(&mut self) -> Option<Capture> {
++    /// Consumes and captures the next non-whitespace token if it's an identifier. Returns
++    /// `None` otherwise.
++    #[must_use]
++    pub fn capture_ident(&mut self) -> Option<Capture> {
+         loop {
+             match self.next_token.kind {
++                TokenKind::Whitespace => self.step(),
+                 TokenKind::Ident => {
+                     let res = Capture {
+                         pos: self.pos,
+@@ -276,60 +242,29 @@ impl<'txt> Cursor<'txt> {
+                     self.step();
+                     return Some(res);
+                 },
+-                TokenKind::Eof => return None,
+-                _ => self.step(),
+-            }
+-        }
+-    }
+-
+-    /// Consume the returns the position of the next non-whitespace token if it's the
+-    /// specified identifier. Returns `None` otherwise.
+-    pub fn match_ident(&mut self, s: &str) -> Option<u32> {
+-        loop {
+-            match self.next_token.kind {
+-                TokenKind::Ident if s == self.peek_text() => {
+-                    let pos = self.pos;
+-                    self.step();
+-                    return Some(pos);
+-                },
+-                TokenKind::Whitespace => self.step(),
+                 _ => return None,
+             }
+         }
+     }
+ 
+-    /// Consumes and captures the next non-whitespace token if it's an identifier. Returns
+-    /// `None` otherwise.
+-    pub fn capture_ident(&mut self) -> Option<Capture> {
++    /// Consumes all tokens up to and including the next identifier. Returns either the
++    /// captured identifier or `None` if one was not found.
++    #[must_use]
++    pub fn find_capture_ident(&mut self) -> Option<Capture> {
+         loop {
+             match self.next_token.kind {
++                TokenKind::Eof => return None,
+                 TokenKind::Ident => {
+-                    let pos = self.pos;
+-                    let len = self.next_token.len;
++                    let res = Capture {
++                        pos: self.pos,
++                        len: self.next_token.len,
++                    };
+                     self.step();
+-                    return Some(Capture { pos, len });
++                    return Some(res);
+                 },
+-                TokenKind::Whitespace => self.step(),
+-                _ => return None,
+-            }
+-        }
+-    }
+-
+-    /// Continually attempt to match the pattern on subsequent tokens until a match is
+-    /// found. Returns whether the pattern was successfully matched.
+-    ///
+-    /// Not generally suitable for multi-token patterns or patterns that can match
+-    /// nothing.
+-    #[must_use]
+-    pub fn find_pat(&mut self, pat: Pat) -> bool {
+-        let mut capture = [].iter_mut();
+-        while !self.match_impl(pat, &mut capture) {
+-            self.step();
+-            if self.at_end() {
+-                return false;
++                _ => self.step(),
+             }
+         }
+-        true
+     }
+ 
+     /// Attempts to match a sequence of patterns at the current position. Returns whether
+@@ -364,14 +299,65 @@ impl<'txt> Cursor<'txt> {
+             .err()
+             .is_none_or(|p| ptr::addr_eq(pats.as_ptr(), p))
+     }
++}
+ 
+-    /// Attempts to match a single pattern at the current position. Returns whether the
+-    /// pattern was successfully matched.
+-    ///
+-    /// If the pattern attempts to capture anything this will panic. If the match fails
+-    /// the cursor will be positioned at the first failing token.
+-    #[must_use]
+-    pub fn match_pat(&mut self, pat: Pat) -> bool {
+-        self.match_impl(pat, &mut [].iter_mut())
++macro_rules! mk_tk_methods {
++    ($(
++        [$desc:literal]
++        $name:ident(&mut $self:tt $($params:tt)*)
++            { $pat:pat $(if $guard:expr)? $(=> $extra:block)? }
++    )*) => {
++        #[allow(dead_code)]
++        impl Cursor<'_> {$(
++            #[doc = "Consumes the next non-whitespace token if it's "]
++            #[doc = $desc]
++            #[doc = " and returns whether the token was found."]
++            #[must_use]
++            pub fn ${concat(eat_, $name)}(&mut $self $($params)*) -> bool {
++                loop {
++                    match $self.next_token.kind {
++                        TokenKind::Whitespace => $self.step(),
++                        $pat $(if $guard)? => {
++                            $self.step();
++                            return true;
++                        },
++                        _ => return false,
++                    }
++                }
++            }
++
++            #[doc = "Consumes all tokens up to and including "]
++            #[doc = $desc]
++            #[doc = " and returns whether the token was found."]
++            #[must_use]
++            pub fn ${concat(find_, $name)}(&mut $self $($params)*) -> bool {
++                loop {
++                    match $self.next_token.kind {
++                        TokenKind::Eof => return false,
++                        $pat $(if $guard)? => {
++                            $self.step();
++                            return true;
++                        },
++                        _ => $self.step(),
++                    }
++                }
++            }
++        )*}
++    }
++}
++mk_tk_methods! {
++    ["`}`"]
++    close_brace(&mut self) { TokenKind::CloseBrace }
++    ["`]`"]
++    close_bracket(&mut self) { TokenKind::CloseBracket }
++    ["`,`"]
++    comma(&mut self) { TokenKind::Comma }
++    ["`::`"]
++    double_colon(&mut self) {
++        TokenKind::Colon if self.inner.as_str().starts_with(':') => { self.step(); }
+     }
++    ["the specified identifier"]
++    ident(&mut self, s: &str) { TokenKind::Ident if self.peek_text() == s }
++    ["`;`"]
++    semi(&mut self) { TokenKind::Semi }
+ }

patches/20261028T105419Z/rust-lang--rust-part011/a725c3e72b72b1da3af04dd8bc265641bfe8cd45.patch

@@ -0,0 +1,584 @@
+diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
+index 019749c77ae66aa98597606dd477fb03cb50f092..58be46690b78882bc0bcfbcf3d7c30750988bc7d 100644
+--- a/library/alloc/src/boxed.rs
++++ b/library/alloc/src/boxed.rs
+@@ -426,82 +426,6 @@ impl<T> Box<T> {
+     pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
+         Box::try_new_zeroed_in(Global)
+     }
+-
+-    /// Maps the value in a box, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on the value in the box, and the result is returned, also boxed.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Box::map(b, f)` instead of `b.map(f)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// let b = Box::new(7);
+-    /// let new = Box::map(b, |i| i + 7);
+-    /// assert_eq!(*new, 14);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> Box<U> {
+-        if size_of::<T>() == size_of::<U>() && align_of::<T>() == align_of::<U>() {
+-            let (value, allocation) = Box::take(this);
+-            Box::write(
+-                unsafe { mem::transmute::<Box<MaybeUninit<T>>, Box<MaybeUninit<U>>>(allocation) },
+-                f(value),
+-            )
+-        } else {
+-            Box::new(f(*this))
+-        }
+-    }
+-
+-    /// Attempts to map the value in a box, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on the value in the box, and if the operation succeeds, the result is
+-    /// returned, also boxed.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Box::try_map(b, f)` instead of `b.try_map(f)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// let b = Box::new(7);
+-    /// let new = Box::try_map(b, u32::try_from).unwrap();
+-    /// assert_eq!(*new, 7);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn try_map<R>(
+-        this: Self,
+-        f: impl FnOnce(T) -> R,
+-    ) -> <R::Residual as Residual<Box<R::Output>>>::TryType
+-    where
+-        R: Try,
+-        R::Residual: Residual<Box<R::Output>>,
+-    {
+-        if size_of::<T>() == size_of::<R::Output>() && align_of::<T>() == align_of::<R::Output>() {
+-            let (value, allocation) = Box::take(this);
+-            try {
+-                Box::write(
+-                    unsafe {
+-                        mem::transmute::<Box<MaybeUninit<T>>, Box<MaybeUninit<R::Output>>>(
+-                            allocation,
+-                        )
+-                    },
+-                    f(value)?,
+-                )
+-            }
+-        } else {
+-            try { Box::new(f(*this)?) }
+-        }
+-    }
+ }
+ 
+ impl<T, A: Allocator> Box<T, A> {
+@@ -776,6 +700,77 @@ impl<T, A: Allocator> Box<T, A> {
+             (value, uninit)
+         }
+     }
++
++    /// Maps the value in a box, reusing the allocation if possible.
++    ///
++    /// `f` is called on the value in the box, and the result is returned, also boxed.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Box::map(b, f)` instead of `b.map(f)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// let b = Box::new(7);
++    /// let new = Box::map(b, |i| i + 7);
++    /// assert_eq!(*new, 14);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> Box<U, A> {
++        let (value, allocation) = Box::take(this);
++        let (raw, alloc) = Box::into_non_null_with_allocator(allocation);
++        if size_of::<T>() == size_of::<U>() && align_of::<T>() == align_of::<U>() {
++            let allocation = unsafe { Box::from_non_null_in(raw.cast::<MaybeUninit<U>>(), alloc) };
++            Box::write(allocation, f(value))
++        } else {
++            unsafe { alloc.deallocate(raw.cast(), Layout::for_value(&value)) }
++            Box::new_in(f(value), alloc)
++        }
++    }
++
++    /// Attempts to map the value in a box, reusing the allocation if possible.
++    ///
++    /// `f` is called on the value in the box, and if the operation succeeds, the result is
++    /// returned, also boxed.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Box::try_map(b, f)` instead of `b.try_map(f)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// let b = Box::new(7);
++    /// let new = Box::try_map(b, u32::try_from).unwrap();
++    /// assert_eq!(*new, 7);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn try_map<R>(
++        this: Self,
++        f: impl FnOnce(T) -> R,
++    ) -> <R::Residual as Residual<Box<R::Output, A>>>::TryType
++    where
++        R: Try,
++        R::Residual: Residual<Box<R::Output, A>>,
++    {
++        let (value, allocation) = Box::take(this);
++        let (raw, alloc) = Box::into_non_null_with_allocator(allocation);
++        if size_of::<T>() == size_of::<R::Output>() && align_of::<T>() == align_of::<R::Output>() {
++            let allocation =
++                unsafe { Box::from_non_null_in(raw.cast::<MaybeUninit<R::Output>>(), alloc) };
++            try { Box::write(allocation, f(value)?) }
++        } else {
++            unsafe { alloc.deallocate(raw.cast(), Layout::for_value(&value)) }
++            try { Box::new_in(f(value)?, alloc) }
++        }
++    }
+ }
+ 
+ impl<T: ?Sized + CloneToUninit> Box<T> {
+diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
+index e4a803f28e1211e109e0450112e68eab13c91e1e..8d954d90c615de7911d7cc164da18c8fb01e482d 100644
+--- a/library/alloc/src/rc.rs
++++ b/library/alloc/src/rc.rs
+@@ -651,93 +651,6 @@ impl<T> Rc<T> {
+     pub fn pin(value: T) -> Pin<Rc<T>> {
+         unsafe { Pin::new_unchecked(Rc::new(value)) }
+     }
+-
+-    /// Maps the value in an `Rc`, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on a reference to the value in the `Rc`, and the result is returned, also in
+-    /// an `Rc`.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Rc::map(r, f)` instead of `r.map(f)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// use std::rc::Rc;
+-    ///
+-    /// let r = Rc::new(7);
+-    /// let new = Rc::map(r, |i| i + 7);
+-    /// assert_eq!(*new, 14);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Rc<U> {
+-        if size_of::<T>() == size_of::<U>()
+-            && align_of::<T>() == align_of::<U>()
+-            && Rc::is_unique(&this)
+-        {
+-            unsafe {
+-                let ptr = Rc::into_raw(this);
+-                let value = ptr.read();
+-                let mut allocation = Rc::from_raw(ptr.cast::<mem::MaybeUninit<U>>());
+-
+-                Rc::get_mut_unchecked(&mut allocation).write(f(&value));
+-                allocation.assume_init()
+-            }
+-        } else {
+-            Rc::new(f(&*this))
+-        }
+-    }
+-
+-    /// Attempts to map the value in an `Rc`, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on a reference to the value in the `Rc`, and if the operation succeeds, the
+-    /// result is returned, also in an `Rc`.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Rc::try_map(r, f)` instead of `r.try_map(f)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// use std::rc::Rc;
+-    ///
+-    /// let b = Rc::new(7);
+-    /// let new = Rc::try_map(b, |&i| u32::try_from(i)).unwrap();
+-    /// assert_eq!(*new, 7);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn try_map<R>(
+-        this: Self,
+-        f: impl FnOnce(&T) -> R,
+-    ) -> <R::Residual as Residual<Rc<R::Output>>>::TryType
+-    where
+-        R: Try,
+-        R::Residual: Residual<Rc<R::Output>>,
+-    {
+-        if size_of::<T>() == size_of::<R::Output>()
+-            && align_of::<T>() == align_of::<R::Output>()
+-            && Rc::is_unique(&this)
+-        {
+-            unsafe {
+-                let ptr = Rc::into_raw(this);
+-                let value = ptr.read();
+-                let mut allocation = Rc::from_raw(ptr.cast::<mem::MaybeUninit<R::Output>>());
+-
+-                Rc::get_mut_unchecked(&mut allocation).write(f(&value)?);
+-                try { allocation.assume_init() }
+-            }
+-        } else {
+-            try { Rc::new(f(&*this)?) }
+-        }
+-    }
+ }
+ 
+ impl<T, A: Allocator> Rc<T, A> {
+@@ -1107,6 +1020,102 @@ impl<T, A: Allocator> Rc<T, A> {
+     pub fn into_inner(this: Self) -> Option<T> {
+         Rc::try_unwrap(this).ok()
+     }
++
++    /// Maps the value in an `Rc`, reusing the allocation if possible.
++    ///
++    /// `f` is called on a reference to the value in the `Rc`, and the result is returned, also in
++    /// an `Rc`.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Rc::map(r, f)` instead of `r.map(f)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// use std::rc::Rc;
++    ///
++    /// let r = Rc::new(7);
++    /// let new = Rc::map(r, |i| i + 7);
++    /// assert_eq!(*new, 14);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Rc<U, A> {
++        if size_of::<T>() == size_of::<U>()
++            && align_of::<T>() == align_of::<U>()
++            && Rc::is_unique(&this)
++        {
++            unsafe {
++                let (ptr, alloc) = Rc::into_raw_with_allocator(this);
++                let value = ptr.read();
++                let mut allocation = Rc::from_raw_in(ptr.cast::<mem::MaybeUninit<U>>(), alloc);
++
++                Rc::get_mut_unchecked(&mut allocation).write(f(&value));
++                allocation.assume_init()
++            }
++        } else {
++            let output = f(&*this);
++            let (ptr, alloc) = Rc::into_raw_with_allocator(this);
++            unsafe { Rc::decrement_strong_count_in(ptr, &alloc) }
++
++            Rc::new_in(output, alloc)
++        }
++    }
++
++    /// Attempts to map the value in an `Rc`, reusing the allocation if possible.
++    ///
++    /// `f` is called on a reference to the value in the `Rc`, and if the operation succeeds, the
++    /// result is returned, also in an `Rc`.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Rc::try_map(r, f)` instead of `r.try_map(f)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// use std::rc::Rc;
++    ///
++    /// let b = Rc::new(7);
++    /// let new = Rc::try_map(b, |&i| u32::try_from(i)).unwrap();
++    /// assert_eq!(*new, 7);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn try_map<R>(
++        this: Self,
++        f: impl FnOnce(&T) -> R,
++    ) -> <R::Residual as Residual<Rc<R::Output, A>>>::TryType
++    where
++        R: Try,
++        R::Residual: Residual<Rc<R::Output, A>>,
++    {
++        if size_of::<T>() == size_of::<R::Output>()
++            && align_of::<T>() == align_of::<R::Output>()
++            && Rc::is_unique(&this)
++        {
++            unsafe {
++                let (ptr, alloc) = Rc::into_raw_with_allocator(this);
++                let value = ptr.read();
++                let mut allocation =
++                    Rc::from_raw_in(ptr.cast::<mem::MaybeUninit<R::Output>>(), alloc);
++
++                Rc::get_mut_unchecked(&mut allocation).write(f(&value)?);
++                try { allocation.assume_init() }
++            }
++        } else {
++            let output = f(&*this)?;
++            let (ptr, alloc) = Rc::into_raw_with_allocator(this);
++            unsafe { Rc::decrement_strong_count_in(ptr, &alloc) }
++
++            try { Rc::new_in(output, alloc) }
++        }
++    }
+ }
+ 
+ impl<T> Rc<[T]> {
+diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
+index 625a29dd9b7a098bd339881a5106eaf5455c2d7a..e72449d670ed256a2769b3d3ca50b069614c4343 100644
+--- a/library/alloc/src/sync.rs
++++ b/library/alloc/src/sync.rs
+@@ -673,93 +673,6 @@ impl<T> Arc<T> {
+             )?))
+         }
+     }
+-
+-    /// Maps the value in an `Arc`, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on a reference to the value in the `Arc`, and the result is returned, also in
+-    /// an `Arc`.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Arc::map(a, f)` instead of `r.map(a)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// use std::sync::Arc;
+-    ///
+-    /// let r = Arc::new(7);
+-    /// let new = Arc::map(r, |i| i + 7);
+-    /// assert_eq!(*new, 14);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Arc<U> {
+-        if size_of::<T>() == size_of::<U>()
+-            && align_of::<T>() == align_of::<U>()
+-            && Arc::is_unique(&this)
+-        {
+-            unsafe {
+-                let ptr = Arc::into_raw(this);
+-                let value = ptr.read();
+-                let mut allocation = Arc::from_raw(ptr.cast::<mem::MaybeUninit<U>>());
+-
+-                Arc::get_mut_unchecked(&mut allocation).write(f(&value));
+-                allocation.assume_init()
+-            }
+-        } else {
+-            Arc::new(f(&*this))
+-        }
+-    }
+-
+-    /// Attempts to map the value in an `Arc`, reusing the allocation if possible.
+-    ///
+-    /// `f` is called on a reference to the value in the `Arc`, and if the operation succeeds, the
+-    /// result is returned, also in an `Arc`.
+-    ///
+-    /// Note: this is an associated function, which means that you have
+-    /// to call it as `Arc::try_map(a, f)` instead of `a.try_map(f)`. This
+-    /// is so that there is no conflict with a method on the inner type.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// #![feature(smart_pointer_try_map)]
+-    ///
+-    /// use std::sync::Arc;
+-    ///
+-    /// let b = Arc::new(7);
+-    /// let new = Arc::try_map(b, |&i| u32::try_from(i)).unwrap();
+-    /// assert_eq!(*new, 7);
+-    /// ```
+-    #[cfg(not(no_global_oom_handling))]
+-    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+-    pub fn try_map<R>(
+-        this: Self,
+-        f: impl FnOnce(&T) -> R,
+-    ) -> <R::Residual as Residual<Arc<R::Output>>>::TryType
+-    where
+-        R: Try,
+-        R::Residual: Residual<Arc<R::Output>>,
+-    {
+-        if size_of::<T>() == size_of::<R::Output>()
+-            && align_of::<T>() == align_of::<R::Output>()
+-            && Arc::is_unique(&this)
+-        {
+-            unsafe {
+-                let ptr = Arc::into_raw(this);
+-                let value = ptr.read();
+-                let mut allocation = Arc::from_raw(ptr.cast::<mem::MaybeUninit<R::Output>>());
+-
+-                Arc::get_mut_unchecked(&mut allocation).write(f(&value)?);
+-                try { allocation.assume_init() }
+-            }
+-        } else {
+-            try { Arc::new(f(&*this)?) }
+-        }
+-    }
+ }
+ 
+ impl<T, A: Allocator> Arc<T, A> {
+@@ -1263,6 +1176,102 @@ impl<T, A: Allocator> Arc<T, A> {
+ 
+         Some(inner)
+     }
++
++    /// Maps the value in an `Arc`, reusing the allocation if possible.
++    ///
++    /// `f` is called on a reference to the value in the `Arc`, and the result is returned, also in
++    /// an `Arc`.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Arc::map(a, f)` instead of `r.map(a)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// use std::sync::Arc;
++    ///
++    /// let r = Arc::new(7);
++    /// let new = Arc::map(r, |i| i + 7);
++    /// assert_eq!(*new, 14);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Arc<U, A> {
++        if size_of::<T>() == size_of::<U>()
++            && align_of::<T>() == align_of::<U>()
++            && Arc::is_unique(&this)
++        {
++            unsafe {
++                let (ptr, alloc) = Arc::into_raw_with_allocator(this);
++                let value = ptr.read();
++                let mut allocation = Arc::from_raw_in(ptr.cast::<mem::MaybeUninit<U>>(), alloc);
++
++                Arc::get_mut_unchecked(&mut allocation).write(f(&value));
++                allocation.assume_init()
++            }
++        } else {
++            let output = f(&*this);
++            let (ptr, alloc) = Arc::into_raw_with_allocator(this);
++            unsafe { Arc::decrement_strong_count_in(ptr, &alloc) }
++
++            Arc::new_in(output, alloc)
++        }
++    }
++
++    /// Attempts to map the value in an `Arc`, reusing the allocation if possible.
++    ///
++    /// `f` is called on a reference to the value in the `Arc`, and if the operation succeeds, the
++    /// result is returned, also in an `Arc`.
++    ///
++    /// Note: this is an associated function, which means that you have
++    /// to call it as `Arc::try_map(a, f)` instead of `a.try_map(f)`. This
++    /// is so that there is no conflict with a method on the inner type.
++    ///
++    /// # Examples
++    ///
++    /// ```
++    /// #![feature(smart_pointer_try_map)]
++    ///
++    /// use std::sync::Arc;
++    ///
++    /// let b = Arc::new(7);
++    /// let new = Arc::try_map(b, |&i| u32::try_from(i)).unwrap();
++    /// assert_eq!(*new, 7);
++    /// ```
++    #[cfg(not(no_global_oom_handling))]
++    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
++    pub fn try_map<R>(
++        this: Self,
++        f: impl FnOnce(&T) -> R,
++    ) -> <R::Residual as Residual<Arc<R::Output, A>>>::TryType
++    where
++        R: Try,
++        R::Residual: Residual<Arc<R::Output, A>>,
++    {
++        if size_of::<T>() == size_of::<R::Output>()
++            && align_of::<T>() == align_of::<R::Output>()
++            && Arc::is_unique(&this)
++        {
++            unsafe {
++                let (ptr, alloc) = Arc::into_raw_with_allocator(this);
++                let value = ptr.read();
++                let mut allocation =
++                    Arc::from_raw_in(ptr.cast::<mem::MaybeUninit<R::Output>>(), alloc);
++
++                Arc::get_mut_unchecked(&mut allocation).write(f(&value)?);
++                try { allocation.assume_init() }
++            }
++        } else {
++            let output = f(&*this)?;
++            let (ptr, alloc) = Arc::into_raw_with_allocator(this);
++            unsafe { Arc::decrement_strong_count_in(ptr, &alloc) }
++
++            try { Arc::new_in(output, alloc) }
++        }
++    }
+ }
+ 
+ impl<T> Arc<[T]> {
+diff --git a/tests/ui/privacy/suggest-box-new.stderr b/tests/ui/privacy/suggest-box-new.stderr
+index 8df8346f772ba48245d3cfe5bcf93635579ca6d7..32525a41f946c3965f6ef734043f2390e3e363d5 100644
+--- a/tests/ui/privacy/suggest-box-new.stderr
++++ b/tests/ui/privacy/suggest-box-new.stderr
+@@ -147,10 +147,10 @@ LL -     let _ = Box::<i32> {};
+ LL +     let _ = Box::<i32>::new_in(_, _);
+    |
+ LL -     let _ = Box::<i32> {};
+-LL +     let _ = Box::<i32>::map(_, _);
++LL +     let _ = Box::<i32>::into_inner(_);
+    |
+ LL -     let _ = Box::<i32> {};
+-LL +     let _ = Box::<i32>::into_inner(_);
++LL +     let _ = Box::<i32>::map(_, _);
+    |
+    = and 7 other candidates
+ help: consider using the `Default` trait

patches/20261028T105419Z/rust-lang--rust-part011/b8dca7f7daf2eb91b65b3e0eeacf4c0ef49959c1.patch

@@ -0,0 +1,20 @@
+diff --git a/src/intrinsic/mod.rs b/src/intrinsic/mod.rs
+index 09ad3254e57146071d8b628b1a797ef5939c6953..b3b1bea68e0b42b3fc9a0089bb4c6ae59ca0c4da 100644
+--- a/src/intrinsic/mod.rs
++++ b/src/intrinsic/mod.rs
+@@ -171,7 +171,6 @@ fn f16_builtin<'gcc, 'tcx>(
+         sym::exp2f16 => "exp2f",
+         sym::fabs => "fabsf",
+         sym::floorf16 => "__builtin_floorf",
+-        sym::fmaf16 => "fmaf",
+         sym::logf16 => "logf",
+         sym::log2f16 => "log2f",
+         sym::log10f16 => "log10f",
+@@ -249,7 +248,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
+             | sym::expf16
+             | sym::exp2f16
+             | sym::floorf16
+-            | sym::fmaf16
+             | sym::logf16
+             | sym::log2f16
+             | sym::log10f16

patches/20261028T105419Z/rust-lang--rust-part011/ba47895f5aee2ae4d79aa146ab7850948b743e33.patch

@@ -0,0 +1,141 @@
+diff --git a/clippy_lints_internal/src/lib.rs b/clippy_lints_internal/src/lib.rs
+index 2d06940981795b8859e9bd68804b124e14210b54..301d37153c94b16df9fd69f5a7b5ff7e4fe5e499 100644
+--- a/clippy_lints_internal/src/lib.rs
++++ b/clippy_lints_internal/src/lib.rs
+@@ -29,7 +29,6 @@ mod internal_paths;
+ mod lint_without_lint_pass;
+ mod msrv_attr_impl;
+ mod outer_expn_data_pass;
+-mod produce_ice;
+ mod repeated_is_diagnostic_item;
+ mod symbols;
+ mod unnecessary_def_path;
+@@ -47,7 +46,6 @@ static LINTS: &[&Lint] = &[
+     lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE,
+     msrv_attr_impl::MISSING_MSRV_ATTR_IMPL,
+     outer_expn_data_pass::OUTER_EXPN_EXPN_DATA,
+-    produce_ice::PRODUCE_ICE,
+     symbols::INTERNING_LITERALS,
+     symbols::SYMBOL_AS_STR,
+     unnecessary_def_path::UNNECESSARY_DEF_PATH,
+@@ -61,7 +59,6 @@ pub fn register_lints(store: &mut LintStore) {
+     store.register_early_lint_pass(Box::new(|| {
+         Box::new(unsorted_clippy_utils_paths::UnsortedClippyUtilsPaths)
+     }));
+-    store.register_early_lint_pass(Box::new(|| Box::new(produce_ice::ProduceIce)));
+     store.register_late_lint_pass(Box::new(|_| Box::new(collapsible_span_lint_calls::CollapsibleCalls)));
+     store.register_late_lint_pass(Box::new(|_| Box::<symbols::Symbols>::default()));
+     store.register_late_lint_pass(Box::new(|_| {
+diff --git a/clippy_lints_internal/src/produce_ice.rs b/clippy_lints_internal/src/produce_ice.rs
+deleted file mode 100644
+index 82a6bcdf36af60fffc3b7ab244d4d1540db58db9..0000000000000000000000000000000000000000
+--- a/clippy_lints_internal/src/produce_ice.rs
++++ /dev/null
+@@ -1,41 +0,0 @@
+-use rustc_ast::ast::NodeId;
+-use rustc_ast::visit::FnKind;
+-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext as _, declare_lint_pass, declare_tool_lint};
+-use rustc_span::Span;
+-
+-declare_tool_lint! {
+-    /// ### What it does
+-    /// Not an actual lint. This lint is only meant for testing our customized internal compiler
+-    /// error message by calling `panic`.
+-    ///
+-    /// ### Why is this bad?
+-    /// ICE in large quantities can damage your teeth
+-    ///
+-    /// ### Example
+-    /// ```rust,ignore
+-    /// 🍦🍦🍦🍦🍦
+-    /// ```
+-    pub clippy::PRODUCE_ICE,
+-    Warn,
+-    "this message should not appear anywhere as we ICE before and don't emit the lint",
+-    report_in_external_macro: true
+-}
+-
+-declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
+-
+-impl EarlyLintPass for ProduceIce {
+-    fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, span: Span, _: NodeId) {
+-        if is_trigger_fn(fn_kind) {
+-            cx.sess()
+-                .dcx()
+-                .span_delayed_bug(span, "Would you like some help with that?");
+-        }
+-    }
+-}
+-
+-fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
+-    match fn_kind {
+-        FnKind::Fn(_, _, func) => func.ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
+-        FnKind::Closure(..) => false,
+-    }
+-}
+diff --git a/tests/ui/custom_ice_message.rs b/tests/ui/custom_ice_message.rs
+index c7e92b1bf164fdc5d88971a2381ad6e34c98f295..0102b9d76ecccddc39d356d165460e3aa023900e 100644
+--- a/tests/ui/custom_ice_message.rs
++++ b/tests/ui/custom_ice_message.rs
+@@ -1,15 +1,13 @@
+ //@rustc-env:RUST_BACKTRACE=0
+ //@normalize-stderr-test: "Clippy version: .*" -> "Clippy version: foo"
+-//@normalize-stderr-test: "produce_ice.rs:\d*:\d*" -> "produce_ice.rs"
+-//@normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
+-//@normalize-stderr-test: "'rustc'" -> "'<unnamed>'"
++//@normalize-stderr-test: "custom_ice_message.rs:\d*:\d*" -> "custom_ice_message.rs"
+ //@normalize-stderr-test: "rustc 1\.\d+.* running on .*" -> "rustc <version> running on <target>"
+ //@normalize-stderr-test: "(?ms)query stack during panic:\n.*end of query stack\n" -> ""
++//@normalize-stderr-test: "note: delayed at .*" -> "note: delayed at <location>"
++//@normalize-stderr-test: "note: compiler flags: .*" -> "note: compiler flags: <flags>"
+ 
+-#![deny(clippy::produce_ice)]
+-#![allow(clippy::missing_clippy_version_attribute)]
+-
+-fn it_looks_like_you_are_trying_to_kill_clippy() {}
+-//~^ ice: Would you like some help with that?
++#![feature(rustc_attrs)]
+ 
++#[rustc_delayed_bug_from_inside_query]
+ fn main() {}
++//~^ ice: delayed bug triggered by
+diff --git a/tests/ui/custom_ice_message.stderr b/tests/ui/custom_ice_message.stderr
+index c21963007c89e95219a74dabfb37dfe69edf00aa..5fc979cfaf67f36b86c55dbf25dd9de22af7c3c2 100644
+--- a/tests/ui/custom_ice_message.stderr
++++ b/tests/ui/custom_ice_message.stderr
+@@ -2,25 +2,23 @@ note: no errors encountered even though delayed bugs were created
+ 
+ note: those delayed bugs will now be shown as internal compiler errors
+ 
+-error: internal compiler error: Would you like some help with that?
+-  --> tests/ui/custom_ice_message.rs:12:1
++error: internal compiler error: delayed bug triggered by #[rustc_delayed_bug_from_inside_query]
++  --> tests/ui/custom_ice_message.rs
+    |
+-LL | fn it_looks_like_you_are_trying_to_kill_clippy() {}
+-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++LL | fn main() {}
++   | ^^^^^^^^^
+    |
+-note: delayed at clippy_lints_internal/src/produce_ice.rs - disabled backtrace
+-  --> tests/ui/custom_ice_message.rs:12:1
++note: delayed at <location>
++  --> tests/ui/custom_ice_message.rs
+    |
+-LL | fn it_looks_like_you_are_trying_to_kill_clippy() {}
+-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++LL | fn main() {}
++   | ^^^^^^^^^
+ 
+-note: we would appreciate a bug report: https://github.com/rust-lang/rust-clippy/issues/new?template=ice.yml
+-
+-note: please make sure that you have updated to the latest nightly
++note: using internal features is not supported and expected to cause internal compiler errors when used incorrectly
+ 
+ note: rustc <version> running on <target>
+ 
+-note: compiler flags: -Z ui-testing -Z deduplicate-diagnostics=no -Z next-solver=coherence
++note: compiler flags: <flags>
+ 
+ note: Clippy version: foo
+ 

patches/20261028T105419Z/rust-lang--rust-part011/ba4efa6a5ab8987bff3a3a962cb45444050cbdec.patch

@@ -0,0 +1,430 @@
+diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
+index 4ced81f5b1d3dc85f2cd26758ee7678cb282d131..078e0f2c6cd867d76ef211596fbc969183a79c39 100644
+--- a/clippy_dev/src/edit_lints.rs
++++ b/clippy_dev/src/edit_lints.rs
+@@ -1,10 +1,8 @@
+ use crate::parse::cursor::{self, Capture, Cursor};
+-use crate::parse::{
+-    ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, ParsedLints, RenamedLint, SourceFile, Span,
+-};
++use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, ParsedLints, RenamedLint};
+ use crate::utils::{
+-    ErrAction, FileUpdater, UpdateMode, UpdateStatus, Version, delete_dir_if_exists, delete_file_if_exists,
+-    expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
++    ErrAction, FileUpdater, SourceFile, Span, UpdateMode, UpdateStatus, Version, delete_dir_if_exists,
++    delete_file_if_exists, expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
+ };
+ use core::mem;
+ use rustc_lexer::TokenKind;
+diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
+index ea136417425ba3ec9aebac0d44044de648ab99cc..b479c4d70c9580c22aabf7ba67e837eae94dcf2c 100644
+--- a/clippy_dev/src/fmt.rs
++++ b/clippy_dev/src/fmt.rs
+@@ -1,8 +1,7 @@
+ use crate::generate::gen_sorted_lints_file;
+ use crate::new_parse_cx;
+-use crate::parse::VecBuf;
+ use crate::utils::{
+-    ErrAction, FileUpdater, UpdateMode, UpdateStatus, expect_action, run_with_output, split_args_for_threads,
++    ErrAction, FileUpdater, UpdateMode, UpdateStatus, VecBuf, expect_action, run_with_output, split_args_for_threads,
+     walk_dir_no_dot_or_target,
+ };
+ use itertools::Itertools as _;
+diff --git a/clippy_dev/src/generate.rs b/clippy_dev/src/generate.rs
+index fe11d87bf06553bdceb33402aa495c542bee4bb1..f250c92f455190bf1ebf5e596bd2e1496946cb72 100644
+--- a/clippy_dev/src/generate.rs
++++ b/clippy_dev/src/generate.rs
+@@ -1,6 +1,6 @@
+ use crate::parse::cursor::Cursor;
+-use crate::parse::{LintData, LintPass, ParsedLints, VecBuf};
+-use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, slice_groups, update_text_region_fn};
++use crate::parse::{LintData, LintPass, ParsedLints};
++use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, VecBuf, slice_groups, update_text_region_fn};
+ use core::range::Range;
+ use itertools::Itertools as _;
+ use std::collections::HashSet;
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index 92edee2b37922b8fe7778c23783700ea76213969..95fb22accc079f46fc8b1b66425340cd99ba4939 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -1,85 +1,15 @@
+ pub mod cursor;
+ 
+ use self::cursor::{Capture, Cursor, IdentPat};
+-use crate::utils::{ErrAction, File, Scoped, expect_action, slice_groups_mut, walk_dir_no_dot_or_target};
+-use core::cell::Cell;
+-use core::fmt::{self, Display, Write as _};
+-use core::hash::{Hash, Hasher};
+-use core::ptr;
++use crate::utils::{
++    ErrAction, Scoped, SourceFile, Span, StrBuf, VecBuf, expect_action, slice_groups_mut, walk_dir_no_dot_or_target,
++};
++use core::fmt::{self, Display};
+ use core::range::Range;
+ use rustc_arena::{DroplessArena, TypedArena};
+ use rustc_data_structures::fx::FxHashMap;
+-use std::str::pattern::Pattern;
+ use std::{fs, path};
+ 
+-#[derive(Eq)]
+-pub struct SourceFile<'cx> {
+-    // `cargo dev rename_lint` needs to be able to rename files.
+-    pub path: Cell<&'cx str>,
+-    pub contents: String,
+-}
+-impl<'cx> SourceFile<'cx> {
+-    pub fn load(path: &'cx str) -> Self {
+-        let mut contents = String::new();
+-        File::open_read(path).read_append_to_string(&mut contents);
+-        SourceFile {
+-            path: Cell::new(path),
+-            contents,
+-        }
+-    }
+-
+-    /// Splits the file's path into the crate it's a part of and the module it implements.
+-    ///
+-    /// Only supports paths in the form `CRATE_NAME/src/PATH/TO/FILE.rs` using the current
+-    /// platform's path separator. The module path returned will use the current platform's
+-    /// path separator.
+-    pub fn path_as_krate_mod(&self) -> (&'cx str, &'cx str) {
+-        let path = self.path.get();
+-        let Some((krate, path)) = path.split_once(path::MAIN_SEPARATOR) else {
+-            return ("", "");
+-        };
+-        let module = if let Some(path) = path.strip_prefix("src")
+-            && let Some(path) = path.strip_prefix(path::MAIN_SEPARATOR)
+-            && let Some(path) = path.strip_suffix(".rs")
+-        {
+-            if path == "lib" {
+-                ""
+-            } else if let Some(path) = path.strip_suffix("mod")
+-                && let Some(path) = path.strip_suffix(path::MAIN_SEPARATOR)
+-            {
+-                path
+-            } else {
+-                path
+-            }
+-        } else {
+-            ""
+-        };
+-        (krate, module)
+-    }
+-}
+-impl PartialEq<SourceFile<'_>> for SourceFile<'_> {
+-    fn eq(&self, other: &SourceFile<'_>) -> bool {
+-        // We should only be creating one source file per path.
+-        ptr::addr_eq(self, other)
+-    }
+-}
+-impl Hash for SourceFile<'_> {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
+-        ptr::hash(self, state);
+-    }
+-}
+-
+-#[derive(Clone, Copy)]
+-pub struct Span<'cx> {
+-    pub file: &'cx SourceFile<'cx>,
+-    pub range: Range<u32>,
+-}
+-impl<'cx> Span<'cx> {
+-    pub fn new(file: &'cx SourceFile<'cx>, range: Range<u32>) -> Self {
+-        Self { file, range }
+-    }
+-}
+-
+ pub struct ParseCxImpl<'cx> {
+     pub arena: &'cx DroplessArena,
+     pub source_files: &'cx TypedArena<SourceFile<'cx>>,
+@@ -100,92 +30,6 @@ pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx, 'env,
+     }))
+ }
+ 
+-/// A string used as a temporary buffer used to avoid allocating for short lived strings.
+-pub struct StrBuf(String);
+-impl StrBuf {
+-    /// Creates a new buffer with the specified initial capacity.
+-    pub fn with_capacity(cap: usize) -> Self {
+-        Self(String::with_capacity(cap))
+-    }
+-
+-    /// Allocates the result of formatting the given value onto the arena.
+-    pub fn alloc_display<'cx>(&mut self, arena: &'cx DroplessArena, value: impl Display) -> &'cx str {
+-        self.0.clear();
+-        write!(self.0, "{value}").expect("`Display` impl returned an error");
+-        arena.alloc_str(&self.0)
+-    }
+-
+-    /// Allocates the string onto the arena with all ascii characters converted to
+-    /// lowercase.
+-    pub fn alloc_ascii_lower<'cx>(&mut self, arena: &'cx DroplessArena, s: &str) -> &'cx str {
+-        self.0.clear();
+-        self.0.push_str(s);
+-        self.0.make_ascii_lowercase();
+-        arena.alloc_str(&self.0)
+-    }
+-
+-    /// Collects all elements into the buffer and allocates that onto the arena.
+-    pub fn alloc_collect<'cx, I>(&mut self, arena: &'cx DroplessArena, iter: I) -> &'cx str
+-    where
+-        I: IntoIterator,
+-        String: Extend<I::Item>,
+-    {
+-        self.0.clear();
+-        self.0.extend(iter);
+-        if self.0.is_empty() {
+-            ""
+-        } else {
+-            arena.alloc_str(&self.0)
+-        }
+-    }
+-
+-    /// Allocates the result of replacing all instances the pattern with the given string
+-    /// onto the arena.
+-    pub fn alloc_replaced<'cx>(
+-        &mut self,
+-        arena: &'cx DroplessArena,
+-        s: &str,
+-        pat: impl Pattern,
+-        replacement: &str,
+-    ) -> &'cx str {
+-        let mut parts = s.split(pat);
+-        let Some(first) = parts.next() else {
+-            return "";
+-        };
+-        self.0.clear();
+-        self.0.push_str(first);
+-        for part in parts {
+-            self.0.push_str(replacement);
+-            self.0.push_str(part);
+-        }
+-        if self.0.is_empty() {
+-            ""
+-        } else {
+-            arena.alloc_str(&self.0)
+-        }
+-    }
+-
+-    /// Performs an operation with the freshly cleared buffer.
+-    pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
+-        self.0.clear();
+-        f(&mut self.0)
+-    }
+-}
+-
+-pub struct VecBuf<T>(Vec<T>);
+-impl<T> VecBuf<T> {
+-    /// Creates a new buffer with the specified initial capacity.
+-    pub fn with_capacity(cap: usize) -> Self {
+-        Self(Vec::with_capacity(cap))
+-    }
+-
+-    /// Performs an operation with the freshly cleared buffer.
+-    pub fn with<R>(&mut self, f: impl FnOnce(&mut Vec<T>) -> R) -> R {
+-        self.0.clear();
+-        f(&mut self.0)
+-    }
+-}
+-
+ #[derive(Clone, Copy, PartialEq, Eq, Hash)]
+ pub enum LintTool {
+     Rustc,
+diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
+index f10540e98ca74b07d8fd9c435c904f8be251b3b3..d3e95ffb87b40c4148a2ccbf85906a85bb4574d9 100644
+--- a/clippy_dev/src/utils.rs
++++ b/clippy_dev/src/utils.rs
+@@ -1,20 +1,22 @@
+-use core::fmt::{self, Display};
++use core::cell::Cell;
++use core::fmt::{self, Display, Write as _};
++use core::hash::{Hash, Hasher};
+ use core::marker::PhantomData;
+-use core::mem;
+ use core::num::NonZero;
+ use core::ops::{Deref, DerefMut};
+ use core::range::Range;
+ use core::str::FromStr;
++use core::str::pattern::Pattern;
++use core::{mem, ptr};
++use rustc_arena::DroplessArena;
+ use std::ffi::OsStr;
+ use std::fs::{self, OpenOptions};
+ use std::io::{self, Read as _, Seek as _, SeekFrom, Write as _};
+-use std::path::{Path, PathBuf};
++use std::path::{self, Path, PathBuf};
+ use std::process::{self, Command, Stdio};
+ use std::{env, thread};
+ use walkdir::WalkDir;
+ 
+-use crate::parse::SourceFile;
+-
+ pub struct Scoped<'inner, 'outer: 'inner, T>(T, PhantomData<&'inner mut T>, PhantomData<&'outer mut ()>);
+ impl<T> Scoped<'_, '_, T> {
+     pub fn new(value: T) -> Self {
+@@ -698,3 +700,165 @@ pub fn slice_groups_mut<T>(
+     }
+     I { slice, split_idx }
+ }
++
++/// A string used as a temporary buffer used to avoid allocating for short lived strings.
++pub struct StrBuf(String);
++impl StrBuf {
++    /// Creates a new buffer with the specified initial capacity.
++    pub fn with_capacity(cap: usize) -> Self {
++        Self(String::with_capacity(cap))
++    }
++
++    /// Allocates the result of formatting the given value onto the arena.
++    pub fn alloc_display<'cx>(&mut self, arena: &'cx DroplessArena, value: impl Display) -> &'cx str {
++        self.0.clear();
++        write!(self.0, "{value}").expect("`Display` impl returned an error");
++        if self.0.is_empty() {
++            ""
++        } else {
++            arena.alloc_str(&self.0)
++        }
++    }
++
++    /// Allocates the string onto the arena with all ascii characters converted to
++    /// lowercase.
++    pub fn alloc_ascii_lower<'cx>(&mut self, arena: &'cx DroplessArena, s: &str) -> &'cx str {
++        self.0.clear();
++        self.0.push_str(s);
++        self.0.make_ascii_lowercase();
++        if self.0.is_empty() {
++            ""
++        } else {
++            arena.alloc_str(&self.0)
++        }
++    }
++
++    /// Collects all elements into the buffer and allocates that onto the arena.
++    pub fn alloc_collect<'cx, I>(&mut self, arena: &'cx DroplessArena, iter: I) -> &'cx str
++    where
++        I: IntoIterator,
++        String: Extend<I::Item>,
++    {
++        self.0.clear();
++        self.0.extend(iter);
++        if self.0.is_empty() {
++            ""
++        } else {
++            arena.alloc_str(&self.0)
++        }
++    }
++
++    /// Allocates the result of replacing all instances the pattern with the given string
++    /// onto the arena.
++    pub fn alloc_replaced<'cx>(
++        &mut self,
++        arena: &'cx DroplessArena,
++        s: &str,
++        pat: impl Pattern,
++        replacement: &str,
++    ) -> &'cx str {
++        let mut parts = s.split(pat);
++        let Some(first) = parts.next() else {
++            return "";
++        };
++        self.0.clear();
++        self.0.push_str(first);
++        for part in parts {
++            self.0.push_str(replacement);
++            self.0.push_str(part);
++        }
++        if self.0.is_empty() {
++            ""
++        } else {
++            arena.alloc_str(&self.0)
++        }
++    }
++
++    /// Performs an operation with the freshly cleared buffer.
++    pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
++        self.0.clear();
++        f(&mut self.0)
++    }
++}
++
++pub struct VecBuf<T>(Vec<T>);
++impl<T> VecBuf<T> {
++    /// Creates a new buffer with the specified initial capacity.
++    pub fn with_capacity(cap: usize) -> Self {
++        Self(Vec::with_capacity(cap))
++    }
++
++    /// Performs an operation with the freshly cleared buffer.
++    pub fn with<R>(&mut self, f: impl FnOnce(&mut Vec<T>) -> R) -> R {
++        self.0.clear();
++        f(&mut self.0)
++    }
++}
++
++#[derive(Eq)]
++pub struct SourceFile<'cx> {
++    // `cargo dev rename_lint` needs to be able to rename files.
++    pub path: Cell<&'cx str>,
++    pub contents: String,
++}
++impl<'cx> SourceFile<'cx> {
++    pub fn load(path: &'cx str) -> Self {
++        let mut contents = String::new();
++        File::open_read(path).read_append_to_string(&mut contents);
++        SourceFile {
++            path: Cell::new(path),
++            contents,
++        }
++    }
++
++    /// Splits the file's path into the crate it's a part of and the module it implements.
++    ///
++    /// Only supports paths in the form `CRATE_NAME/src/PATH/TO/FILE.rs` using the current
++    /// platform's path separator. The module path returned will use the current platform's
++    /// path separator.
++    pub fn path_as_krate_mod(&self) -> (&'cx str, &'cx str) {
++        let path = self.path.get();
++        let Some((krate, path)) = path.split_once(path::MAIN_SEPARATOR) else {
++            return ("", "");
++        };
++        let module = if let Some(path) = path.strip_prefix("src")
++            && let Some(path) = path.strip_prefix(path::MAIN_SEPARATOR)
++            && let Some(path) = path.strip_suffix(".rs")
++        {
++            if path == "lib" {
++                ""
++            } else if let Some(path) = path.strip_suffix("mod")
++                && let Some(path) = path.strip_suffix(path::MAIN_SEPARATOR)
++            {
++                path
++            } else {
++                path
++            }
++        } else {
++            ""
++        };
++        (krate, module)
++    }
++}
++impl PartialEq<SourceFile<'_>> for SourceFile<'_> {
++    fn eq(&self, other: &SourceFile<'_>) -> bool {
++        // We should only be creating one source file per path.
++        ptr::addr_eq(self, other)
++    }
++}
++impl Hash for SourceFile<'_> {
++    fn hash<H: Hasher>(&self, state: &mut H) {
++        ptr::hash(self, state);
++    }
++}
++
++#[derive(Clone, Copy)]
++pub struct Span<'cx> {
++    pub file: &'cx SourceFile<'cx>,
++    pub range: Range<u32>,
++}
++impl<'cx> Span<'cx> {
++    pub fn new(file: &'cx SourceFile<'cx>, range: Range<u32>) -> Self {
++        Self { file, range }
++    }
++}

patches/20261028T105419Z/rust-lang--rust-part011/bceece16f135c3862071c51ebabf7d4e42114e35.patch

@@ -0,0 +1,41 @@
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
+index bd1ad70fe6a1426882505480e825f479593916b6..44f410408a40a22aeee96517233852be11e31204 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
+@@ -491,6 +491,12 @@ impl<'db> MirLowerCtx<'_, 'db> {
+                 )?
+             }
+             Pat::Ref { pat, mutability: _ } => {
++                let ty = cond_place.ty(&self.result, &self.infcx, self.env).ty;
++                if !ty.is_ref() {
++                    return Err(MirLowerError::TypeError(
++                        "non reference type matched with reference pattern",
++                    ));
++                }
+                 let cond_place = cond_place.project(ProjectionElem::Deref);
+                 self.pattern_match_inner(current, current_else, cond_place, *pat, mode)?
+             }
+diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
+index 1f6aa5c926b152448c2a1e737864e93f0cccdde1..e4f3b61be4556412eea887d5db2e7953fc6acbab 100644
+--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
++++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
+@@ -49,3 +49,19 @@ fn foo() {
+     "#,
+     );
+ }
++
++#[test]
++fn ref_pattern_on_unresolved_alias() {
++    lower_mir(
++        r#"
++//- minicore: sized
++trait Tr {
++    type A;
++}
++
++fn f<T: Tr>(x: T::A) {
++    let &() = x;
++}
++"#,
++    );
++}

patches/20261028T105419Z/rust-lang--rust-part011/bedeb1e61284f000f0958bc3c04da7b68ef4abb3.patch

@@ -0,0 +1,180 @@
+diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
+index d4e7fdfdba52175945e3961f44d2aa59dd07946b..2bc30b61d346a0d5237e710cc99b1bb265266635 100644
+--- a/clippy_dev/src/parse.rs
++++ b/clippy_dev/src/parse.rs
+@@ -354,22 +354,18 @@ impl<'cx> ParseCxImpl<'cx> {
+         #[rustfmt::skip]
+         static LINT_DECL_TOKENS: &[cursor::Pat] = &[
+             // !{ /// docs
+-            Bang, OpenBrace, AnyComment,
++            Bang, OpenBrace, AnyComments,
+             // #[clippy::version = "version"]
+             Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
+             Ident(IdentPat::version), Eq, LitStr, CloseBracket,
+             // pub NAME, GROUP,
+-            Ident(IdentPat::r#pub), CaptureIdent, Comma, AnyComment, CaptureIdent, Comma,
+-        ];
+-        #[rustfmt::skip]
+-        static PASS_DECL_TOKENS: &[cursor::Pat] = &[
+-            // !( NAME <'lt> => [
+-            Bang, OpenParen, CaptureDocLines, CaptureIdent, CaptureOptLifetimeArg, FatArrow, OpenBracket,
++            Ident(IdentPat::r#pub), CaptureIdent, Comma, AnyComments, CaptureIdent, Comma,
+         ];
+ 
+         let mut cursor = Cursor::new(&file.contents);
+         let mut captures = [Capture::EMPTY; 3];
+         while let Some(mac_name) = cursor.find_any_ident() {
++            captures[1] = Capture::EMPTY;
+             match cursor.get_text(mac_name) {
+                 "declare_clippy_lint"
+                     if cursor.match_all(LINT_DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) =>
+@@ -387,7 +383,11 @@ impl<'cx> ParseCxImpl<'cx> {
+                             .is_none()
+                     );
+                 },
+-                mac @ ("declare_lint_pass" | "impl_lint_pass") if cursor.match_all(PASS_DECL_TOKENS, &mut captures) => {
++                mac @ ("declare_lint_pass" | "impl_lint_pass")
++                    if cursor.match_all(&[Bang, OpenParen, CaptureDocLines, CaptureIdent], &mut captures)
++                        && cursor.opt_match_all(&[Lt, CaptureLifetime, Gt], &mut captures[2..])
++                        && cursor.match_all(&[FatArrow, OpenBracket], &mut captures) =>
++                {
+                     let mac = if matches!(mac, "declare_lint_pass") {
+                         LintPassMac::Declare
+                     } else {
+diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
+index 5a30931040a323383ecca651979c70934ca49d3c..c7ad710f8d20987f68877db73ad9b10796c698ae 100644
+--- a/clippy_dev/src/parse/cursor.rs
++++ b/clippy_dev/src/parse/cursor.rs
+@@ -1,4 +1,4 @@
+-use core::slice;
++use core::{ptr, slice};
+ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+ 
+ /// A token pattern used for searching and matching by the [`Cursor`].
+@@ -9,12 +9,11 @@ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+ /// the `*`.
+ #[derive(Clone, Copy)]
+ pub enum Pat {
+-    Ident(IdentPat),
+     /// Matches any number of comments and doc comments.
+-    AnyComment,
++    AnyComments,
+     CaptureDocLines,
+     CaptureIdent,
+-    LitStr,
++    CaptureLifetime,
+     CaptureLitStr,
+     Bang,
+     CloseBrace,
+@@ -24,13 +23,14 @@ pub enum Pat {
+     DoubleColon,
+     Eq,
+     FatArrow,
++    Gt,
++    Ident(IdentPat),
+     Lifetime,
++    LitStr,
+     Lt,
+-    Gt,
+     OpenBrace,
+     OpenBracket,
+     OpenParen,
+-    CaptureOptLifetimeArg,
+     Pound,
+     Semi,
+ }
+@@ -145,14 +145,13 @@ impl<'txt> Cursor<'txt> {
+     ///
+     /// For each capture made by the pattern one item will be taken from the capture
+     /// sequence with the result placed inside.
+-    #[expect(clippy::too_many_lines)]
+     fn match_impl(&mut self, pat: Pat, captures: &mut slice::IterMut<'_, Capture>) -> bool {
+         loop {
+             match (pat, self.next_token.kind) {
+                 #[rustfmt::skip] // rustfmt bug: https://github.com/rust-lang/rustfmt/issues/6697
+                 (_, TokenKind::Whitespace)
+                 | (
+-                    Pat::AnyComment,
++                    Pat::AnyComments,
+                     TokenKind::BlockComment { terminated: true, .. } | TokenKind::LineComment { .. },
+                 ) => self.step(),
+                 (Pat::Bang, TokenKind::Bang)
+@@ -199,34 +198,6 @@ impl<'txt> Cursor<'txt> {
+                     }
+                     return false;
+                 },
+-                (Pat::CaptureOptLifetimeArg, TokenKind::Lt) => {
+-                    self.step();
+-                    loop {
+-                        match self.next_token.kind {
+-                            TokenKind::Lifetime { .. } => break,
+-                            TokenKind::Whitespace => self.step(),
+-                            _ => return false,
+-                        }
+-                    }
+-                    *captures.next().unwrap() = Capture {
+-                        pos: self.pos,
+-                        len: self.next_token.len,
+-                    };
+-                    self.step();
+-                    loop {
+-                        match self.next_token.kind {
+-                            TokenKind::Gt => break,
+-                            TokenKind::Whitespace => self.step(),
+-                            _ => return false,
+-                        }
+-                    }
+-                    self.step();
+-                    return true;
+-                },
+-                (Pat::CaptureOptLifetimeArg, _) => {
+-                    *captures.next().unwrap() = Capture { pos: 0, len: 0 };
+-                    return true;
+-                },
+                 #[rustfmt::skip]
+                 (
+                     Pat::CaptureLitStr,
+@@ -237,7 +208,8 @@ impl<'txt> Cursor<'txt> {
+                         ..
+                     },
+                 )
+-                | (Pat::CaptureIdent, TokenKind::Ident) => {
++                | (Pat::CaptureIdent, TokenKind::Ident)
++                | (Pat::CaptureLifetime, TokenKind::Lifetime { .. }) => {
+                     *captures.next().unwrap() = Capture { pos: self.pos, len: self.next_token.len };
+                     self.step();
+                     return true;
+@@ -263,7 +235,7 @@ impl<'txt> Cursor<'txt> {
+                     *captures.next().unwrap() = Capture::EMPTY;
+                     return true;
+                 },
+-                (Pat::AnyComment, _) => return true,
++                (Pat::AnyComments, _) => return true,
+                 _ => return false,
+             }
+         }
+@@ -375,6 +347,24 @@ impl<'txt> Cursor<'txt> {
+         pats.iter().all(|&p| self.match_impl(p, &mut captures))
+     }
+ 
++    /// Attempts to match a sequence of patterns at the current position. Returns whether
++    /// all patterns were successfully matched.
++    ///
++    /// Captures will be written to the given slice in the order they're matched. If a
++    /// capture is matched, but there are no more capture slots this will panic. If the
++    /// match is completed without filling all the capture slots they will be left
++    /// unmodified.
++    ///
++    /// If the match fails the cursor will be positioned at the first failing token.
++    #[must_use]
++    pub fn opt_match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> bool {
++        let mut captures = captures.iter_mut();
++        pats.iter()
++            .try_for_each(|p| self.match_impl(*p, &mut captures).ok_or(p))
++            .err()
++            .is_none_or(|p| ptr::addr_eq(pats.as_ptr(), p))
++    }
++
+     /// Attempts to match a single pattern at the current position. Returns whether the
+     /// pattern was successfully matched.
+     ///

patches/20261028T105419Z/rust-lang--rust-part011/d02b65b54d71567d7cc1d668a4524aab9b5eb33c.patch

@@ -0,0 +1,192 @@
+diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
+index a782f4aca6c53a49e2b483d8931b957556b59074..f323d7040d260c99e24fa063996ddaa171b58d18 100644
+--- a/book/src/lint_configuration.md
++++ b/book/src/lint_configuration.md
+@@ -907,7 +907,7 @@ crate. For example, `pub(crate)` items.
+ ## `module-item-order-groupings`
+ The named groupings of different source item kinds within modules.
+ 
+-**Default Value:** `[["modules", ["extern_crate", "mod", "foreign_mod"]], ["use", ["use"]], ["macros", ["macro"]], ["global_asm", ["global_asm"]], ["UPPER_SNAKE_CASE", ["static", "const"]], ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl"]], ["lower_snake_case", ["fn"]]]`
++**Default Value:** `[["modules", ["extern_crate", "mod", "foreign_mod"]], ["use", ["use"]], ["macros", ["macro"]], ["global_asm", ["global_asm"]], ["UPPER_SNAKE_CASE", ["static", "const"]], ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl", "test_binder_constraints"]], ["lower_snake_case", ["fn"]]]`
+ 
+ ---
+ **Affected lints:**
+diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
+index 4dc2549c6e233d130cb123f0f300b42aa603c232..fd602e4ca5b25b585e9cc23f9990433717d99208 100644
+--- a/clippy_config/src/types.rs
++++ b/clippy_config/src/types.rs
+@@ -459,6 +459,7 @@ conf_enum! {
+         TraitAlias("trait_alias"),
+         Impl("impl"),
+         Fn("fn"),
++        TestBinderConstraints("test_binder_constraints"),
+     }
+ }
+ 
+@@ -483,6 +484,7 @@ impl SourceItemOrderingModuleItemKind {
+             TraitAlias,
+             Impl,
+             Fn,
++            TestBinderConstraints,
+         ]
+     }
+ }
+@@ -648,6 +650,7 @@ impl FromDefault<()> for SourceItemOrderingModuleItemGroupings {
+                         SourceItemOrderingModuleItemKind::Trait,
+                         SourceItemOrderingModuleItemKind::TraitAlias,
+                         SourceItemOrderingModuleItemKind::Impl,
++                        SourceItemOrderingModuleItemKind::TestBinderConstraints,
+                     ],
+                 ),
+                 ("lower_snake_case".into(), vec![SourceItemOrderingModuleItemKind::Fn]),
+@@ -668,6 +671,7 @@ impl FromDefault<()> for SourceItemOrderingModuleItemGroupings {
+                 (SourceItemOrderingModuleItemKind::Trait, 5),
+                 (SourceItemOrderingModuleItemKind::TraitAlias, 5),
+                 (SourceItemOrderingModuleItemKind::Impl, 5),
++                (SourceItemOrderingModuleItemKind::TestBinderConstraints, 5),
+                 (SourceItemOrderingModuleItemKind::Fn, 6),
+             ]),
+             back_lut: HashMap::from_iter([
+@@ -686,12 +690,16 @@ impl FromDefault<()> for SourceItemOrderingModuleItemGroupings {
+                 (SourceItemOrderingModuleItemKind::Trait, "PascalCase".into()),
+                 (SourceItemOrderingModuleItemKind::TraitAlias, "PascalCase".into()),
+                 (SourceItemOrderingModuleItemKind::Impl, "PascalCase".into()),
++                (
++                    SourceItemOrderingModuleItemKind::TestBinderConstraints,
++                    "PascalCase".into(),
++                ),
+                 (SourceItemOrderingModuleItemKind::Fn, "lower_snake_case".into()),
+             ]),
+         }
+     }
+     fn display_default((): ()) -> impl Display {
+-        r#"[["modules", ["extern_crate", "mod", "foreign_mod"]], ["use", ["use"]], ["macros", ["macro"]], ["global_asm", ["global_asm"]], ["UPPER_SNAKE_CASE", ["static", "const"]], ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl"]], ["lower_snake_case", ["fn"]]]"#
++        r#"[["modules", ["extern_crate", "mod", "foreign_mod"]], ["use", ["use"]], ["macros", ["macro"]], ["global_asm", ["global_asm"]], ["UPPER_SNAKE_CASE", ["static", "const"]], ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl", "test_binder_constraints"]], ["lower_snake_case", ["fn"]]]"#
+     }
+ }
+ impl DeserializeOrDefault<()> for SourceItemOrderingModuleItemGroupings {
+diff --git a/clippy_lints/src/arbitrary_source_item_ordering.rs b/clippy_lints/src/arbitrary_source_item_ordering.rs
+index 73b63697d844d3d054a72514b4f28f63dfdbebe2..65ef6f63e9777df68164e2c4ec38f5e0ab33a258 100644
+--- a/clippy_lints/src/arbitrary_source_item_ordering.rs
++++ b/clippy_lints/src/arbitrary_source_item_ordering.rs
+@@ -630,6 +630,7 @@ fn convert_module_item_kind(value: &ItemKind<'_>) -> SourceItemOrderingModuleIte
+         ItemKind::Trait { .. } => Trait,
+         ItemKind::TraitAlias(..) => TraitAlias,
+         ItemKind::Impl(..) => Impl,
++        ItemKind::TestBinderConstraints { .. } => TestBinderConstraints,
+     }
+ }
+ 
+diff --git a/clippy_lints/src/definition_in_module_root.rs b/clippy_lints/src/definition_in_module_root.rs
+index 14c440abfd98239ec10b77400fa18521db9ae40c..035f2160de21ae17aac49dded4c45c49db41914f 100644
+--- a/clippy_lints/src/definition_in_module_root.rs
++++ b/clippy_lints/src/definition_in_module_root.rs
+@@ -139,7 +139,8 @@ fn definition_kind(item: &ast::Item) -> Option<&'static str> {
+         | ItemKind::MacCall(..)
+         | ItemKind::MacroDef(..)
+         | ItemKind::Delegation(..)
+-        | ItemKind::DelegationMac(..) => None,
++        | ItemKind::DelegationMac(..)
++        | ItemKind::TestBinderConstraints(..) => None,
+     }
+ }
+ 
+diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
+index a78faf0be976a33169c81237149a3602d9980425..8c604aadc811e00be5a7519a14d14d8fdf94b21a 100644
+--- a/clippy_lints/src/item_name_repetitions.rs
++++ b/clippy_lints/src/item_name_repetitions.rs
+@@ -533,7 +533,11 @@ impl LateLintPass<'_> for ItemNameRepetitions {
+             | ItemKind::Union(ident, ..)
+             | ItemKind::Use(_, UseKind::Single(ident)) => ident,
+ 
+-            ItemKind::ForeignMod { .. } | ItemKind::GlobalAsm { .. } | ItemKind::Impl(_) | ItemKind::Use(..) => return,
++            ItemKind::ForeignMod { .. }
++            | ItemKind::GlobalAsm { .. }
++            | ItemKind::Impl(_)
++            | ItemKind::Use(..)
++            | ItemKind::TestBinderConstraints { .. } => return,
+         };
+ 
+         let item_name = ident.name.as_str();
+diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
+index 38359500434928a1165b76a1d54563ae6b353dff..5e1d12179aacd873a1096616842e8355de9ec7b4 100644
+--- a/clippy_lints/src/manual_float_methods.rs
++++ b/clippy_lints/src/manual_float_methods.rs
+@@ -118,7 +118,8 @@ fn is_not_const(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
+         | DefKind::Impl { .. }
+         | DefKind::OpaqueTy
+         | DefKind::SyntheticCoroutineBody
+-        | DefKind::TyParam => true,
++        | DefKind::TyParam
++        | DefKind::TestBinderConstraints => true,
+ 
+         DefKind::AnonConst
+         | DefKind::Const { .. }
+diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
+index 28fd8b33b71032fd96d401a6094904067f06c0a9..e5a292806259d548d79b177be322918d62e4467e 100644
+--- a/clippy_lints/src/min_ident_chars.rs
++++ b/clippy_lints/src/min_ident_chars.rs
+@@ -142,7 +142,8 @@ impl LateLintPass<'_> for MinIdentChars {
+             | ItemKind::ForeignMod { .. }
+             | ItemKind::GlobalAsm { .. }
+             | ItemKind::Impl(_)
+-            | ItemKind::Use(..) => return,
++            | ItemKind::Use(..)
++            | ItemKind::TestBinderConstraints { .. } => return,
+         };
+         if let Some(missing) = self.check_sym(ident.name)
+             && !(matches!(i.kind, ItemKind::Fn { .. })
+diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
+index 30d88207b863720ffb003acc5329a0ae60a4e7b0..51423b9811fcbc0e518eed82ec0388ce800462d1 100644
+--- a/clippy_lints/src/missing_doc.rs
++++ b/clippy_lints/src/missing_doc.rs
+@@ -140,7 +140,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
+             ItemKind::ExternCrate(..)
+             | ItemKind::ForeignMod { .. }
+             | ItemKind::GlobalAsm { .. }
+-            | ItemKind::Use(..) => return,
++            | ItemKind::Use(..)
++            | ItemKind::TestBinderConstraints { .. } => return,
+ 
+             ItemKind::Mod(ident, ..) => {
+                 if item.span.from_expansion() && item.span.eq_ctxt(ident.span) {
+diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
+index cbbbca7e60388945c018422e86c7fcf4de126bfe..4cf8b680955272823486724f22f3a3886719b225 100644
+--- a/clippy_utils/src/check_proc_macro.rs
++++ b/clippy_utils/src/check_proc_macro.rs
+@@ -288,6 +288,7 @@ fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
+         ItemKind::TraitAlias(..) => (Pat::Str("trait"), Pat::Str(";")),
+         ItemKind::GlobalAsm { .. } => return (Pat::Str("global_asm"), Pat::Str("")),
+         ItemKind::Use(..) => return (Pat::Str(""), Pat::Str("")),
++        ItemKind::TestBinderConstraints { .. } => return (Pat::Str(""), Pat::Str("")),
+     };
+     if item.vis_span.is_empty() {
+         (start_pat, end_pat)
+diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
+index 464b5fcfeb04e071495b4a4342ca4a308c542e63..76313e2fdd7ae59eabde9e1d4ddd93ace8799382 100644
+--- a/clippy_utils/src/lib.rs
++++ b/clippy_utils/src/lib.rs
+@@ -2788,7 +2788,9 @@ pub fn expr_use_sites<'tcx>(
+                 | Node::TraitRef(_)
+                 | Node::Ty(_)
+                 | Node::TyPat(_)
+-                | Node::WherePredicate(_) => {
++                | Node::WherePredicate(_)
++                | Node::TestBinderForall(_)
++                | Node::TestBinderExists(_) => {
+                     // This shouldn't be possible to hit; the inner iterator should have
+                     // been moved to the end before we hit any of these nodes.
+                     debug_assert!(false, "found {parent:?} which is after the final use node");
+diff --git a/tests/ui-toml/arbitrary_source_item_ordering/default_exp/clippy.toml b/tests/ui-toml/arbitrary_source_item_ordering/default_exp/clippy.toml
+index af3aa1cc62a49f9a0a966ee1fb6ec12af4bd69ee..8d02935ea2de03ea80a28efe36713a233690df26 100644
+--- a/tests/ui-toml/arbitrary_source_item_ordering/default_exp/clippy.toml
++++ b/tests/ui-toml/arbitrary_source_item_ordering/default_exp/clippy.toml
+@@ -6,7 +6,7 @@ module-item-order-groupings = [
+     ["macros", ["macro"]],
+     ["global_asm", ["global_asm"]],
+     ["UPPER_SNAKE_CASE", ["static", "const"]],
+-    ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl"]],
++    ["PascalCase", ["ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl", "test_binder_constraints"]],
+     ["lower_snake_case", ["fn"]]
+ ]
+ module-items-ordered-within-groupings = "none"

patches/20261028T105419Z/rust-lang--rust-part011/db59539ce6f8be0394f91699763b2c8256946983.patch

@@ -0,0 +1,197 @@
+diff --git a/clippy_lints/src/transmute/missing_transmute_annotations.rs b/clippy_lints/src/transmute/missing_transmute_annotations.rs
+index ddcc577cbd199dcc345be0149fecd60000938b78..4321eff7be63e19cf5f48a8568b020cf82ff1da6 100644
+--- a/clippy_lints/src/transmute/missing_transmute_annotations.rs
++++ b/clippy_lints/src/transmute/missing_transmute_annotations.rs
+@@ -5,6 +5,7 @@ use clippy_utils::source::SpanExt as _;
+ use rustc_errors::Applicability;
+ use rustc_hir::{Expr, GenericArg, HirId, LetStmt, Node, Path, TyKind};
+ use rustc_lint::LateContext;
++use rustc_middle::ty::print::with_types_for_suggestion;
+ use rustc_middle::ty::{self, Ty};
+ use rustc_span::Span;
+ 
+@@ -95,7 +96,7 @@ pub(super) fn check<'tcx>(
+                 diag.span_suggestion(
+                     span,
+                     "consider adding missing annotations",
+-                    format!("{}::<{from_ty}, {to_ty}>", last.ident),
++                    with_types_for_suggestion!(format!("{}::<{from_ty}, {to_ty}>", last.ident)),
+                     Applicability::MaybeIncorrect,
+                 );
+             }
+diff --git a/tests/ui/missing_transmute_annotations.fixed b/tests/ui/missing_transmute_annotations.fixed
+index 2602a2fda51353effb54b9799a8a795df23cf2da..a719d793cc7850d5c28419b01ba49bd49f181df2 100644
+--- a/tests/ui/missing_transmute_annotations.fixed
++++ b/tests/ui/missing_transmute_annotations.fixed
+@@ -9,7 +9,7 @@ extern crate macro_rules;
+ macro_rules! local_bad_transmute {
+     ($e:expr) => {
+         std::mem::transmute::<[u16; 2], i32>($e)
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+     };
+ }
+ 
+@@ -36,18 +36,18 @@ unsafe fn foo2() -> i32 {
+     unsafe {
+         let mut i: i32 = 0;
+         i = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         let x: i32 = bar(std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]));
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         bar(std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]));
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i = local_bad_transmute!([1u16, 2u16]);
+ 
+@@ -55,21 +55,30 @@ unsafe fn foo2() -> i32 {
+         i = bad_transmute!([1u16, 2u16]);
+ 
+         i = std::mem::transmute::<[i16; 2], i32>([0i16, 0i16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i = std::mem::transmute::<Foo, i32>(Foo::A);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i
+     }
+ }
+ 
++#[expect(invalid_value)]
++// https://github.com/rust-lang/rust-clippy/issues/15839
++fn function_name_in_suggestion() {
++    trait T {}
++    struct S(*mut dyn T);
++    let _ = S(unsafe { std::mem::transmute::<(usize, usize), *mut dyn T>((0usize, 0usize)) });
++    //~^ missing_transmute_annotations
++}
++
+ fn main() {
+     let x: _ = unsafe { std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]) };
+-    //~^ ERROR: transmute used without annotations
++    //~^ missing_transmute_annotations
+     unsafe {
+         let x: _ = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         // Should not warn.
+         std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+diff --git a/tests/ui/missing_transmute_annotations.rs b/tests/ui/missing_transmute_annotations.rs
+index fe7b7238d33fe3b4be4afb55787d34624c4b3a75..ac0724244cff557729ba844a92f6d44c8366798c 100644
+--- a/tests/ui/missing_transmute_annotations.rs
++++ b/tests/ui/missing_transmute_annotations.rs
+@@ -9,7 +9,7 @@ extern crate macro_rules;
+ macro_rules! local_bad_transmute {
+     ($e:expr) => {
+         std::mem::transmute($e)
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+     };
+ }
+ 
+@@ -36,18 +36,18 @@ unsafe fn foo2() -> i32 {
+     unsafe {
+         let mut i: i32 = 0;
+         i = std::mem::transmute([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<_, _>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<_, i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         i = std::mem::transmute::<[u16; 2], _>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         let x: i32 = bar(std::mem::transmute::<[u16; 2], _>([1u16, 2u16]));
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+         bar(std::mem::transmute::<[u16; 2], _>([1u16, 2u16]));
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i = local_bad_transmute!([1u16, 2u16]);
+ 
+@@ -55,21 +55,30 @@ unsafe fn foo2() -> i32 {
+         i = bad_transmute!([1u16, 2u16]);
+ 
+         i = std::mem::transmute([0i16, 0i16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i = std::mem::transmute(Foo::A);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         i
+     }
+ }
+ 
++#[expect(invalid_value)]
++// https://github.com/rust-lang/rust-clippy/issues/15839
++fn function_name_in_suggestion() {
++    trait T {}
++    struct S(*mut dyn T);
++    let _ = S(unsafe { std::mem::transmute((0usize, 0usize)) });
++    //~^ missing_transmute_annotations
++}
++
+ fn main() {
+     let x: _ = unsafe { std::mem::transmute::<_, i32>([1u16, 2u16]) };
+-    //~^ ERROR: transmute used without annotations
++    //~^ missing_transmute_annotations
+     unsafe {
+         let x: _ = std::mem::transmute::<_, i32>([1u16, 2u16]);
+-        //~^ ERROR: transmute used without annotations
++        //~^ missing_transmute_annotations
+ 
+         // Should not warn.
+         std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+diff --git a/tests/ui/missing_transmute_annotations.stderr b/tests/ui/missing_transmute_annotations.stderr
+index 63f7e28ee7dc61c0af54bcce8dd2a010b2c7ce5f..d4854c122da5c46abfde7ff79a23d39a76be4fe7 100644
+--- a/tests/ui/missing_transmute_annotations.stderr
++++ b/tests/ui/missing_transmute_annotations.stderr
+@@ -61,16 +61,22 @@ LL |         i = std::mem::transmute(Foo::A);
+    |                       ^^^^^^^^^ help: consider adding missing annotations: `transmute::<Foo, i32>`
+ 
+ error: transmute used without annotations
+-  --> tests/ui/missing_transmute_annotations.rs:68:35
++  --> tests/ui/missing_transmute_annotations.rs:72:34
++   |
++LL |     let _ = S(unsafe { std::mem::transmute((0usize, 0usize)) });
++   |                                  ^^^^^^^^^ help: consider adding missing annotations: `transmute::<(usize, usize), *mut dyn T>`
++
++error: transmute used without annotations
++  --> tests/ui/missing_transmute_annotations.rs:77:35
+    |
+ LL |     let x: _ = unsafe { std::mem::transmute::<_, i32>([1u16, 2u16]) };
+    |                                   ^^^^^^^^^^^^^^^^^^^ help: consider adding missing annotations: `transmute::<[u16; 2], i32>`
+ 
+ error: transmute used without annotations
+-  --> tests/ui/missing_transmute_annotations.rs:71:30
++  --> tests/ui/missing_transmute_annotations.rs:80:30
+    |
+ LL |         let x: _ = std::mem::transmute::<_, i32>([1u16, 2u16]);
+    |                              ^^^^^^^^^^^^^^^^^^^ help: consider adding missing annotations: `transmute::<[u16; 2], i32>`
+ 
+-error: aborting due to 11 previous errors
++error: aborting due to 12 previous errors
+ 

patches/20261028T105419Z/rust-lang--rust-part011/deb81605189b7df985187428eb2ef9f934e2804d.patch

@@ -0,0 +1,293 @@
+diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
+index 811536a5f221e6c0b227b6b4fd3cc5b11cc4987a..11cdbea3c426a3c40f2ae37333b9b60e9d82356c 100644
+--- a/compiler/rustc_lint_defs/src/builtin.rs
++++ b/compiler/rustc_lint_defs/src/builtin.rs
+@@ -289,6 +289,8 @@ declare_lint! {
+     /// enum Foo { A }
+     /// ```
+     ///
++    /// {{produces}}
++    ///
+     /// ### Explanation
+     ///
+     /// While some representations may be specified more than once, the compiler
+diff --git a/tests/ui/repr/repr-repeated-attrs.rs b/tests/ui/repr/repr-repeated-attrs.rs
+new file mode 100644
+index 0000000000000000000000000000000000000000..a6dd3fb6e8b15776c7e8862666cd614b38b2b6e8
+--- /dev/null
++++ b/tests/ui/repr/repr-repeated-attrs.rs
+@@ -0,0 +1,68 @@
++// Tests to ensure we warn on repeated `#[repr(..)]` attributes.
++
++#[repr(transparent, transparent)]
++//~^ ERROR transparent struct cannot have other repr hints
++#[repr(transparent)]
++struct SeveralTransparentReprs(*mut u8);
++
++#[repr(transparent)]
++//~^ ERROR transparent struct cannot have other repr hints
++#[repr(transparent)]
++struct MultilineOnly(*mut u8);
++
++#[repr(Rust, Rust)]
++//~^ WARN representation attribute is specified more than once
++struct SeveralRustReprs(u8);
++
++#[repr(C, C)]
++//~^ WARN representation attribute is specified more than once
++#[repr(C, C, C)]
++struct SeveralC(u8);
++
++#[repr(u8, u8)]
++//~^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
++enum SeveralPrimitiveRerprs {
++    Variant,
++}
++
++#[repr(C, C, u8)] //~ WARN representation attribute is specified more than once
++//~^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
++#[repr(C, u8, u8)]
++enum SeveralCAndPrims {
++    Variant(u8),
++}
++
++#[repr(Rust, u8, u8)]
++//~^ ERROR conflicting representation hints
++//~^^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
++enum RustAndPrimDisallowed {
++    Variant(u8),
++}
++
++#[repr(u8, u8)] //~ ERROR conflicting representation hints
++//~^ WARN this was previously accepted
++#[repr(u16)]
++enum ConflictingPrimReprs {
++    Variant,
++}
++
++#[repr(C, u8)]
++//~^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
++enum CWithIntsCausesFCW1 {
++    A,
++    B,
++}
++
++#[repr(C, C, u8, u8, u8)] //~ WARN representation attribute is specified more than once
++//~^ ERROR conflicting representation hints
++//~| WARN this was previously accepted
++enum CWithIntsCausesFCW2 {
++    A,
++    B,
++}
++
++fn main() {}
+diff --git a/tests/ui/repr/repr-repeated-attrs.stderr b/tests/ui/repr/repr-repeated-attrs.stderr
+new file mode 100644
+index 0000000000000000000000000000000000000000..72c312a13ea11adf3b3d21f1898c7299be0cf66a
+--- /dev/null
++++ b/tests/ui/repr/repr-repeated-attrs.stderr
+@@ -0,0 +1,200 @@
++error[E0692]: transparent struct cannot have other repr hints
++  --> $DIR/repr-repeated-attrs.rs:3:8
++   |
++LL | #[repr(transparent, transparent)]
++   |        ^^^^^^^^^^^  ^^^^^^^^^^^
++LL |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++
++error[E0692]: transparent struct cannot have other repr hints
++  --> $DIR/repr-repeated-attrs.rs:8:8
++   |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++LL |
++LL | #[repr(transparent)]
++   |        ^^^^^^^^^^^
++
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:13:8
++   |
++LL | #[repr(Rust, Rust)]
++   |        ^^^^  ^^^^
++   |
++   = note: for consistency, only specify the representation once
++   = note: `#[warn(repeated_reprs)]` on by default
++
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:17:8
++   |
++LL | #[repr(C, C)]
++   |        ^  ^
++LL |
++LL | #[repr(C, C, C)]
++   |        ^  ^  ^
++   |
++   = note: for consistency, only specify the representation once
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:22:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:29:8
++   |
++LL | #[repr(C, C, u8)]
++   |        ^  ^  ^^
++...
++LL | #[repr(C, u8, u8)]
++   |        ^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:29:8
++   |
++LL | #[repr(C, C, u8)]
++   |        ^  ^  ^^
++...
++LL | #[repr(C, u8, u8)]
++   |        ^  ^^  ^^
++   |
++   = note: for consistency, only specify the representation once
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:37:8
++   |
++LL | #[repr(Rust, u8, u8)]
++   |        ^^^^  ^^  ^^
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:37:8
++   |
++LL | #[repr(Rust, u8, u8)]
++   |        ^^^^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:44:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++LL |
++LL | #[repr(u16)]
++   |        ^^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:51:8
++   |
++LL | #[repr(C, u8)]
++   |        ^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:59:8
++   |
++LL | #[repr(C, C, u8, u8, u8)]
++   |        ^  ^  ^^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++
++warning: representation attribute is specified more than once
++  --> $DIR/repr-repeated-attrs.rs:59:8
++   |
++LL | #[repr(C, C, u8, u8, u8)]
++   |        ^  ^  ^^  ^^  ^^
++   |
++   = note: for consistency, only specify the representation once
++
++error: aborting due to 9 previous errors; 4 warnings emitted
++
++Some errors have detailed explanations: E0566, E0692.
++For more information about an error, try `rustc --explain E0566`.
++Future incompatibility report: Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:22:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:29:8
++   |
++LL | #[repr(C, C, u8)]
++   |        ^  ^  ^^
++...
++LL | #[repr(C, u8, u8)]
++   |        ^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:37:8
++   |
++LL | #[repr(Rust, u8, u8)]
++   |        ^^^^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:44:8
++   |
++LL | #[repr(u8, u8)]
++   |        ^^  ^^
++LL |
++LL | #[repr(u16)]
++   |        ^^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:51:8
++   |
++LL | #[repr(C, u8)]
++   |        ^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++
++Future breakage diagnostic:
++error[E0566]: conflicting representation hints
++  --> $DIR/repr-repeated-attrs.rs:59:8
++   |
++LL | #[repr(C, C, u8, u8, u8)]
++   |        ^  ^  ^^  ^^  ^^
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
++   = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
++

patches/20261028T105419Z/rust-lang--rust-part011/e845ed8cc9c0c18cd30c71f7f7b1e2918531e84a.patch

@@ -0,0 +1,48 @@
+diff --git a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
+index 12705809e4290e81d97fc1a1539abbdbe08c4244..efdbcbae63467c778f2a9cbb1094b348ae615725 100644
+--- a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
++++ b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
+@@ -79,9 +79,9 @@ RUN /tmp/build-fuchsia-toolchain.sh
+ COPY host-x86_64/dist-various-2/build-x86_64-fortanix-unknown-sgx-toolchain.sh /tmp/
+ RUN /tmp/build-x86_64-fortanix-unknown-sgx-toolchain.sh
+ 
+-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-33/wasi-sdk-33.0-x86_64-linux.tar.gz | \
++RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-34/wasi-sdk-34.0-x86_64-linux.tar.gz | \
+   tar -xz
+-ENV WASI_SDK_PATH=/tmp/wasi-sdk-33.0-x86_64-linux
++ENV WASI_SDK_PATH=/tmp/wasi-sdk-34.0-x86_64-linux
+ 
+ COPY scripts/freebsd-toolchain.sh /tmp/
+ RUN /tmp/freebsd-toolchain.sh i686
+diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+index acbd99db6c4f8343e726ac5106772e647e970466..0a9b6f0fda91c0c345df9756fab8793e1553f83f 100644
+--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
++++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+@@ -21,9 +21,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
+   mingw-w64 \
+   && rm -rf /var/lib/apt/lists/*
+ 
+-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-33/wasi-sdk-33.0-x86_64-linux.tar.gz | \
++RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-34/wasi-sdk-34.0-x86_64-linux.tar.gz | \
+   tar -xz
+-ENV WASI_SDK_PATH=/wasi-sdk-33.0-x86_64-linux
++ENV WASI_SDK_PATH=/wasi-sdk-34.0-x86_64-linux
+ 
+ ENV RUST_CONFIGURE_ARGS="--set rust.validate-mir-opts=3"
+ 
+diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile
+index 26e77bc5da200ff6a1328337e1594a38168aace0..6034f3d1d883c69d63938d1ce4fb0cb87339d407 100644
+--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
++++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
+@@ -43,9 +43,9 @@ WORKDIR /
+ COPY scripts/sccache.sh /scripts/
+ RUN sh /scripts/sccache.sh
+ 
+-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-33/wasi-sdk-33.0-x86_64-linux.tar.gz | \
++RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-34/wasi-sdk-34.0-x86_64-linux.tar.gz | \
+   tar -xz
+-ENV WASI_SDK_PATH=/wasi-sdk-33.0-x86_64-linux
++ENV WASI_SDK_PATH=/wasi-sdk-34.0-x86_64-linux
+ 
+ ENV RUST_CONFIGURE_ARGS="--musl-root-x86_64=/usr/local/x86_64-linux-musl \
+   --set rust.lld"

patches/20261028T105419Z/rust-lang--rust-part011/e99f23fec0b37494a9361b02fe509997896c5e37.patch

@@ -0,0 +1,496 @@
+diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
+index 852f1cfda5168cb276db0467d6282d2810611de4..1a392ae1c05da77401159147aa04c74adbf258b6 100644
+--- a/compiler/rustc_lint/src/lib.rs
++++ b/compiler/rustc_lint/src/lib.rs
+@@ -367,7 +367,8 @@ fn register_builtins(store: &mut LintStore) {
+         UNUSED_PARENS,
+         UNUSED_BRACES,
+         REDUNDANT_SEMICOLONS,
+-        MAP_UNIT_FN
++        MAP_UNIT_FN,
++        REPEATED_REPRS
+     );
+ 
+     add_lint_group!("let_underscore", LET_UNDERSCORE_DROP, LET_UNDERSCORE_LOCK);
+diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
+index 11cdbea3c426a3c40f2ae37333b9b60e9d82356c..af5db6117f7b58651a1b00fc2632f3ee1ae6e9ea 100644
+--- a/compiler/rustc_lint_defs/src/builtin.rs
++++ b/compiler/rustc_lint_defs/src/builtin.rs
+@@ -95,6 +95,7 @@ pub mod hardwired {
+             REFINING_IMPL_TRAIT_INTERNAL,
+             REFINING_IMPL_TRAIT_REACHABLE,
+             RENAMED_AND_REMOVED_LINTS,
++            REPEATED_REPRS,
+             REPR_C_ENUMS_LARGER_THAN_INT,
+             RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
+             RTSAN_NONBLOCKING_ASYNC,
+diff --git a/tests/ui/attributes/issue-100631.rs b/tests/ui/attributes/issue-100631.rs
+index 9a30691a39ec38723ec803c8dcfe4dff4fb0e043..09b34ebfe7a2cac715083fef2d83d5f492f07ace 100644
+--- a/tests/ui/attributes/issue-100631.rs
++++ b/tests/ui/attributes/issue-100631.rs
+@@ -1,3 +1,4 @@
++//@ compile-flags: -W repeated-reprs
+ // issue #100631, make sure `TyCtxt::get_attr` only called by case that compiler
+ // can reasonably deal with multiple attributes.
+ // `repr` will use `TyCtxt::get_attrs` since it's `DuplicatesOk`.
+diff --git a/tests/ui/attributes/issue-100631.stderr b/tests/ui/attributes/issue-100631.stderr
+index 0ecc19ae85b3d9d8851ddef81a0ec6da492983e4..62d82c9b31335d521456e077c5c6b26bf1846fde 100644
+--- a/tests/ui/attributes/issue-100631.stderr
++++ b/tests/ui/attributes/issue-100631.stderr
+@@ -1,5 +1,5 @@
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/issue-100631.rs:4:8
++  --> $DIR/issue-100631.rs:5:8
+    |
+ LL | #[repr(C)]
+    |        ^
+@@ -8,10 +8,10 @@ LL | #[repr(C)]
+    |        ^
+    |
+    = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
++   = note: requested on the command line with `-W repeated-reprs`
+ 
+ error[E0084]: unsupported representation for zero-variant enum
+-  --> $DIR/issue-100631.rs:4:8
++  --> $DIR/issue-100631.rs:5:8
+    |
+ LL | #[repr(C)]
+    |        ^
+diff --git a/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr b/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
+index f40fb73acbb8bb51f6f29085dddc289aae031824..b0eb5636d04790da8e0f8ccc99ef7e8bf1f17830 100644
+--- a/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
++++ b/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
+@@ -449,3 +449,21 @@ note: the lint level is defined here
+ LL | #![forbid(forbidden_lint_groups)]
+    |           ^^^^^^^^^^^^^^^^^^^^^
+ 
++Future breakage diagnostic:
++error: warn(unused) incompatible with previous forbid
++  --> $DIR/issue-70819-dont-override-forbid-in-same-scope.rs:22:13
++   |
++LL |     #![forbid(unused)]
++   |               ------ `forbid` level set here
++LL |     #![deny(unused)]
++LL |     #![warn(unused)]
++   |             ^^^^^^ overruled by previous forbid
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #81670 <https://github.com/rust-lang/rust/issues/81670>
++note: the lint level is defined here
++  --> $DIR/issue-70819-dont-override-forbid-in-same-scope.rs:17:11
++   |
++LL | #![forbid(forbidden_lint_groups)]
++   |           ^^^^^^^^^^^^^^^^^^^^^
++
+diff --git a/tests/ui/lint/outer-forbid.stderr b/tests/ui/lint/outer-forbid.stderr
+index abe5959176d4a3774a7da0120c594b5a94bb848f..b2d7ad6c2aabcb817e960f1ef874eefb2041bf87 100644
+--- a/tests/ui/lint/outer-forbid.stderr
++++ b/tests/ui/lint/outer-forbid.stderr
+@@ -489,3 +489,21 @@ note: the lint level is defined here
+ LL | #![forbid(forbidden_lint_groups)]
+    |           ^^^^^^^^^^^^^^^^^^^^^
+ 
++Future breakage diagnostic:
++error: allow(unused) incompatible with previous forbid
++  --> $DIR/outer-forbid.rs:25:9
++   |
++LL | #![forbid(unused, non_snake_case)]
++   |           ------ `forbid` level set here
++...
++LL | #[allow(unused)]
++   |         ^^^^^^ overruled by previous forbid
++   |
++   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
++   = note: for more information, see issue #81670 <https://github.com/rust-lang/rust/issues/81670>
++note: the lint level is defined here
++  --> $DIR/outer-forbid.rs:18:11
++   |
++LL | #![forbid(forbidden_lint_groups)]
++   |           ^^^^^^^^^^^^^^^^^^^^^
++
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.rs b/tests/ui/lint/unused/unused-attr-duplicate.rs
+index c013041ed4159192965aee2df1ce33862ba01b26..c62fc6036f60fc498ef710866e4a920bfaf1ea6a 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.rs
++++ b/tests/ui/lint/unused/unused-attr-duplicate.rs
+@@ -1,6 +1,6 @@
+ // Tests for repeating attribute warnings.
+ //@ aux-build:lint_unused_extern_crate.rs
+-//@ compile-flags:--test
++//@ compile-flags:--test -W repeated-reprs
+ // Not tested due to extra requirements:
+ // - panic_handler: needs extra setup
+ // - target_feature: platform-specific
+diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+index 6e4f7d23604c29224329ba678d8a5ffb514e2d01..feb1a79bf9b926b44998d48a68e69949135436b4 100644
+--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
++++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
+@@ -25,7 +25,7 @@ LL | #[repr(C)]
+    |        ^
+    |
+    = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
++   = note: requested on the command line with `-W repeated-reprs`
+ 
+ error: unused attribute
+   --> $DIR/unused-attr-duplicate.rs:14:1
+diff --git a/tests/ui/repr/conflicting-repr-hints.rs b/tests/ui/repr/conflicting-repr-hints.rs
+index 81a94aad78ff664db86444b89d0ce97815494c0a..6a265e13ad93d6292c1cc562893bdc70c340e1a7 100644
+--- a/tests/ui/repr/conflicting-repr-hints.rs
++++ b/tests/ui/repr/conflicting-repr-hints.rs
+@@ -1,3 +1,4 @@
++//@ compile-flags: -W repeated-reprs
+ #![allow(dead_code)]
+ 
+ #[repr(C)]
+diff --git a/tests/ui/repr/conflicting-repr-hints.stderr b/tests/ui/repr/conflicting-repr-hints.stderr
+index 8f2655fd716f186b5918e9d8e19250d2e4ac27fd..2a81610e85f99739f53a3521742a191e98be1792 100644
+--- a/tests/ui/repr/conflicting-repr-hints.stderr
++++ b/tests/ui/repr/conflicting-repr-hints.stderr
+@@ -1,5 +1,5 @@
+ error[E0566]: conflicting representation hints
+-  --> $DIR/conflicting-repr-hints.rs:13:8
++  --> $DIR/conflicting-repr-hints.rs:14:8
+    |
+ LL | #[repr(C, u64)]
+    |        ^  ^^^
+@@ -9,7 +9,7 @@ LL | #[repr(C, u64)]
+    = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/conflicting-repr-hints.rs:19:8
++  --> $DIR/conflicting-repr-hints.rs:20:8
+    |
+ LL | #[repr(u32, u64)]
+    |        ^^^  ^^^
+@@ -18,70 +18,70 @@ LL | #[repr(u32, u64)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/conflicting-repr-hints.rs:46:8
++  --> $DIR/conflicting-repr-hints.rs:47:8
+    |
+ LL | #[repr(packed, packed(1))]
+    |        ^^^^^^  ^^^^^^^^^
+    |
+    = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
++   = note: requested on the command line with `-W repeated-reprs`
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:29:1
++  --> $DIR/conflicting-repr-hints.rs:30:1
+    |
+ LL | struct F(i32);
+    | ^^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:33:1
++  --> $DIR/conflicting-repr-hints.rs:34:1
+    |
+ LL | struct G(i32);
+    | ^^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:37:1
++  --> $DIR/conflicting-repr-hints.rs:38:1
+    |
+ LL | struct H(i32);
+    | ^^^^^^^^
+ 
+ error[E0634]: type has conflicting packed representation hints
+-  --> $DIR/conflicting-repr-hints.rs:40:1
++  --> $DIR/conflicting-repr-hints.rs:41:1
+    |
+ LL | struct I(i32);
+    | ^^^^^^^^
+ 
+ error[E0634]: type has conflicting packed representation hints
+-  --> $DIR/conflicting-repr-hints.rs:44:1
++  --> $DIR/conflicting-repr-hints.rs:45:1
+    |
+ LL | struct J(i32);
+    | ^^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:50:1
++  --> $DIR/conflicting-repr-hints.rs:51:1
+    |
+ LL | union X {
+    | ^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:57:1
++  --> $DIR/conflicting-repr-hints.rs:58:1
+    |
+ LL | union Y {
+    | ^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:64:1
++  --> $DIR/conflicting-repr-hints.rs:65:1
+    |
+ LL | union Z {
+    | ^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:70:1
++  --> $DIR/conflicting-repr-hints.rs:71:1
+    |
+ LL | pub struct S(u16);
+    | ^^^^^^^^^^^^
+ 
+ error[E0587]: type has conflicting packed and align representation hints
+-  --> $DIR/conflicting-repr-hints.rs:73:1
++  --> $DIR/conflicting-repr-hints.rs:74:1
+    |
+ LL | pub union U {
+    | ^^^^^^^^^^^
+@@ -92,7 +92,7 @@ Some errors have detailed explanations: E0566, E0587, E0634.
+ For more information about an error, try `rustc --explain E0566`.
+ Future incompatibility report: Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/conflicting-repr-hints.rs:13:8
++  --> $DIR/conflicting-repr-hints.rs:14:8
+    |
+ LL | #[repr(C, u64)]
+    |        ^  ^^^
+@@ -103,7 +103,7 @@ LL | #[repr(C, u64)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/conflicting-repr-hints.rs:19:8
++  --> $DIR/conflicting-repr-hints.rs:20:8
+    |
+ LL | #[repr(u32, u64)]
+    |        ^^^  ^^^
+diff --git a/tests/ui/repr/repr-repeated-attrs.rs b/tests/ui/repr/repr-repeated-attrs.rs
+index 7306b9192f09eb79deb39a8a9c4bc6b886591106..122eb9b7485efed89047a9a474fc0bf5a230a855 100644
+--- a/tests/ui/repr/repr-repeated-attrs.rs
++++ b/tests/ui/repr/repr-repeated-attrs.rs
+@@ -1,4 +1,5 @@
+ // Tests to ensure we warn on repeated `#[repr(..)]` attributes.
++//@ compile-flags: -W repeated-reprs
+ 
+ #[repr(transparent, transparent)] //~ WARN `#[repr(..)]` attribute is specified more than once [repeated_reprs]
+ //~^ ERROR transparent struct cannot have other repr hints
+diff --git a/tests/ui/repr/repr-repeated-attrs.stderr b/tests/ui/repr/repr-repeated-attrs.stderr
+index a0b8b1d7da3cc58d1eae30809f115711a2b65948..a1e54f621888950c88f4b4fe315502883d7c7c05 100644
+--- a/tests/ui/repr/repr-repeated-attrs.stderr
++++ b/tests/ui/repr/repr-repeated-attrs.stderr
+@@ -1,5 +1,5 @@
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:3:8
++  --> $DIR/repr-repeated-attrs.rs:4:8
+    |
+ LL | #[repr(transparent, transparent)]
+    |        ^^^^^^^^^^^  ^^^^^^^^^^^
+@@ -8,10 +8,10 @@ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+    |
+    = note: for consistency, only specify the representation once
+-   = note: `#[warn(repeated_reprs)]` on by default
++   = note: requested on the command line with `-W repeated-reprs`
+ 
+ error[E0692]: transparent struct cannot have other repr hints
+-  --> $DIR/repr-repeated-attrs.rs:3:8
++  --> $DIR/repr-repeated-attrs.rs:4:8
+    |
+ LL | #[repr(transparent, transparent)]
+    |        ^^^^^^^^^^^  ^^^^^^^^^^^
+@@ -20,7 +20,7 @@ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:8:8
++  --> $DIR/repr-repeated-attrs.rs:9:8
+    |
+ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+@@ -31,7 +31,7 @@ LL | #[repr(transparent)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0692]: transparent struct cannot have other repr hints
+-  --> $DIR/repr-repeated-attrs.rs:8:8
++  --> $DIR/repr-repeated-attrs.rs:9:8
+    |
+ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+@@ -40,7 +40,7 @@ LL | #[repr(transparent)]
+    |        ^^^^^^^^^^^
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:13:8
++  --> $DIR/repr-repeated-attrs.rs:14:8
+    |
+ LL | #[repr(Rust, Rust)]
+    |        ^^^^  ^^^^
+@@ -48,7 +48,7 @@ LL | #[repr(Rust, Rust)]
+    = note: for consistency, only specify the representation once
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:17:8
++  --> $DIR/repr-repeated-attrs.rs:18:8
+    |
+ LL | #[repr(C, C)]
+    |        ^  ^
+@@ -59,7 +59,7 @@ LL | #[repr(C, C, C)]
+    = note: for consistency, only specify the representation once
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:22:8
++  --> $DIR/repr-repeated-attrs.rs:23:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -67,7 +67,7 @@ LL | #[repr(u8, u8)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:22:8
++  --> $DIR/repr-repeated-attrs.rs:23:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -77,7 +77,7 @@ LL | #[repr(u8, u8)]
+    = note: `#[deny(conflicting_repr_hints)]` (part of `#[deny(future_incompatible)]`) on by default
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:29:8
++  --> $DIR/repr-repeated-attrs.rs:30:8
+    |
+ LL | #[repr(C, C, u8)]
+    |        ^  ^  ^^
+@@ -88,7 +88,7 @@ LL | #[repr(C, u8, u8)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:29:8
++  --> $DIR/repr-repeated-attrs.rs:30:8
+    |
+ LL | #[repr(C, C, u8)]
+    |        ^  ^  ^^
+@@ -100,7 +100,7 @@ LL | #[repr(C, u8, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:37:14
++  --> $DIR/repr-repeated-attrs.rs:38:14
+    |
+ LL | #[repr(Rust, u8, u8)]
+    |              ^^  ^^
+@@ -108,13 +108,13 @@ LL | #[repr(Rust, u8, u8)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:37:8
++  --> $DIR/repr-repeated-attrs.rs:38:8
+    |
+ LL | #[repr(Rust, u8, u8)]
+    |        ^^^^  ^^  ^^
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:37:8
++  --> $DIR/repr-repeated-attrs.rs:38:8
+    |
+ LL | #[repr(Rust, u8, u8)]
+    |        ^^^^  ^^  ^^
+@@ -123,7 +123,7 @@ LL | #[repr(Rust, u8, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:45:8
++  --> $DIR/repr-repeated-attrs.rs:46:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -131,7 +131,7 @@ LL | #[repr(u8, u8)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:45:8
++  --> $DIR/repr-repeated-attrs.rs:46:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -143,7 +143,7 @@ LL | #[repr(u16)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:53:8
++  --> $DIR/repr-repeated-attrs.rs:54:8
+    |
+ LL | #[repr(C, u8)]
+    |        ^  ^^
+@@ -152,7 +152,7 @@ LL | #[repr(C, u8)]
+    = note: for more information, see issue #68585 <https://github.com/rust-lang/rust/issues/68585>
+ 
+ warning: `#[repr(..)]` attribute is specified more than once
+-  --> $DIR/repr-repeated-attrs.rs:61:8
++  --> $DIR/repr-repeated-attrs.rs:62:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+@@ -160,7 +160,7 @@ LL | #[repr(C, C, u8, u8, u8)]
+    = note: for consistency, only specify the representation once
+ 
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:61:8
++  --> $DIR/repr-repeated-attrs.rs:62:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^
+@@ -174,7 +174,7 @@ Some errors have detailed explanations: E0566, E0692.
+ For more information about an error, try `rustc --explain E0566`.
+ Future incompatibility report: Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:22:8
++  --> $DIR/repr-repeated-attrs.rs:23:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -185,7 +185,7 @@ LL | #[repr(u8, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:29:8
++  --> $DIR/repr-repeated-attrs.rs:30:8
+    |
+ LL | #[repr(C, C, u8)]
+    |        ^  ^  ^^
+@@ -199,7 +199,7 @@ LL | #[repr(C, u8, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:37:8
++  --> $DIR/repr-repeated-attrs.rs:38:8
+    |
+ LL | #[repr(Rust, u8, u8)]
+    |        ^^^^  ^^  ^^
+@@ -210,7 +210,7 @@ LL | #[repr(Rust, u8, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:45:8
++  --> $DIR/repr-repeated-attrs.rs:46:8
+    |
+ LL | #[repr(u8, u8)]
+    |        ^^  ^^
+@@ -224,7 +224,7 @@ LL | #[repr(u16)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:53:8
++  --> $DIR/repr-repeated-attrs.rs:54:8
+    |
+ LL | #[repr(C, u8)]
+    |        ^  ^^
+@@ -235,7 +235,7 @@ LL | #[repr(C, u8)]
+ 
+ Future breakage diagnostic:
+ error[E0566]: conflicting representation hints
+-  --> $DIR/repr-repeated-attrs.rs:61:8
++  --> $DIR/repr-repeated-attrs.rs:62:8
+    |
+ LL | #[repr(C, C, u8, u8, u8)]
+    |        ^  ^  ^^  ^^  ^^

patches/20261028T105419Z/rust-lang--rust-part011/fddaffe8e045a15eee8127b22317fb95b1a10127.patch

@@ -0,0 +1,697 @@
+diff --git a/compiler/rustc_monomorphize/src/diagnostics.rs b/compiler/rustc_monomorphize/src/diagnostics.rs
+index 51ce633f55a54637618631248db66cf43223057b..a1930dbea3cda8fbc57d6f369bb322b381d02eaa 100644
+--- a/compiler/rustc_monomorphize/src/diagnostics.rs
++++ b/compiler/rustc_monomorphize/src/diagnostics.rs
+@@ -101,18 +101,23 @@ pub(crate) struct EncounteredErrorWhileInstantiatingGlobalAsm {
+ pub(crate) struct StartNotFound;
+ 
+ #[derive(Diagnostic)]
+-#[diag("this function {$is_call ->
+-    [true] call
+-    *[false] definition
+-} uses {$is_scalable ->
+-    [true] scalable
+-    *[false] SIMD
+-} vector type `{$ty}` which (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled{$is_call ->
+-    [true] {\" \"}in the caller
+-    *[false] {\"\"}
+-}")]
++#[diag(
++    "this function {$is_call ->
++        [true] call
++        *[false] definition
++    } requires the `{$required_feature}` target feature, which is not enabled{$is_call ->
++        [true] {\" \"}in the caller
++        *[false] {\"\"}
++    }"
++)]
++#[note(
++    "the function has type `{$ty}` in its signature, which is passed in {$is_scalable ->
++        [true] scalable
++        *[false] SIMD
++    } vector registers under the \"{$abi}\" ABI"
++)]
+ #[help(
+-    "consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable=\"{$required_feature}\")]`)"
++    "consider enabling the missing target feature globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable=\"{$required_feature}\")]`)"
+ )]
+ pub(crate) struct AbiErrorDisabledVectorType<'a> {
+     #[primary_span]
+@@ -124,6 +129,7 @@ pub(crate) struct AbiErrorDisabledVectorType<'a> {
+     )]
+     pub span: Span,
+     pub required_feature: &'a str,
++    pub abi: String,
+     pub ty: Ty<'a>,
+     /// Whether this is a problem at a call site or at a declaration.
+     pub is_call: bool,
+diff --git a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
+index e6c278bd8ce7b25d1dc7fcea701a7fe3f309bffb..24c42892766e7a592e901b4bf96f7b7a119403a3 100644
+--- a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
++++ b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
+@@ -84,6 +84,7 @@ fn do_check_simd_vector_abi<'tcx>(
+                     tcx.dcx().emit_err(diagnostics::AbiErrorDisabledVectorType {
+                         span,
+                         required_feature: feature,
++                        abi: abi.conv.to_string(),
+                         ty: arg_abi.layout.ty,
+                         is_call,
+                         is_scalable: false,
+@@ -101,6 +102,7 @@ fn do_check_simd_vector_abi<'tcx>(
+                     tcx.dcx().emit_err(diagnostics::AbiErrorDisabledVectorType {
+                         span,
+                         required_feature,
++                        abi: abi.conv.to_string(),
+                         ty: arg_abi.layout.ty,
+                         is_call,
+                         is_scalable: true,
+@@ -170,12 +172,8 @@ fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
+         tcx.dcx().delayed_bug("ABI computation failure should lead to compilation failure");
+         return;
+     };
+-    // Unlike the call-site check, we do also check "Rust" ABI functions here.
+-    // This should never trigger, *except* if we start making use of vector registers
+-    // for the "Rust" ABI and the user disables those vector registers (which should trigger a
+-    // warning as that's clearly disabling a "required" target feature for this target).
+-    // Using such a function is where disabling the vector register actually can start leading
+-    // to soundness issues, so erroring here seems good.
++    // Unlike the call-site check, we do also check "Rust" ABI functions here. This can actually
++    // trigger due to scalable vectors being require for the "Rust" ABI for some types.
+     let loc = || {
+         let def_id = instance.def_id();
+         (
+diff --git a/tests/ui/abi/simd-abi-checks-avx.stderr b/tests/ui/abi/simd-abi-checks-avx.stderr
+index 7489ca0194600b98d5a0882e23bcebcd794e223b..38e5310d34b26253be5cc3eff14f5178dc02a855 100644
+--- a/tests/ui/abi/simd-abi-checks-avx.stderr
++++ b/tests/ui/abi/simd-abi-checks-avx.stderr
+@@ -1,90 +1,101 @@
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:59:11
+    |
+ LL |         f(g());
+    |           ^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:59:9
+    |
+ LL |         f(g());
+    |         ^^^^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:65:14
+    |
+ LL |         gavx(favx());
+    |              ^^^^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:65:9
+    |
+ LL |         gavx(favx());
+    |         ^^^^^^^^^^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:75:19
+    |
+ LL |         w(Wrapper(g()));
+    |                   ^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:75:9
+    |
+ LL |         w(Wrapper(g()));
+    |         ^^^^^^^^^^^^^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `Wrapper` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:89:9
+    |
+ LL |         some_extern();
+    |         ^^^^^^^^^^^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
++error: this function definition requires the `avx` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-avx.rs:24:1
+    |
+ LL | unsafe extern "C" fn g() -> __m256 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function definition uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
++error: this function definition requires the `avx` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-avx.rs:19:1
+    |
+ LL | unsafe extern "C" fn f(_: __m256) {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper` which (with the chosen ABI) requires the `avx` target feature, which is not enabled
++error: this function definition requires the `avx` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-avx.rs:14:1
+    |
+ LL | unsafe extern "C" fn w(_: Wrapper) {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `Wrapper` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+-error: this function call uses SIMD vector type `std::arch::x86_64::__m256` which (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
++error: this function call requires the `avx` target feature, which is not enabled in the caller
+   --> $DIR/simd-abi-checks-avx.rs:53:8
+    |
+ LL |     || g()
+    |        ^^^ function called here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
++   = note: the function has type `std::arch::x86_64::__m256` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+ 
+ note: the above error was encountered while instantiating `fn in_closure::{closure#0}`
+   --> $DIR/simd-abi-checks-avx.rs:81:9
+diff --git a/tests/ui/abi/simd-abi-checks-s390x.z10.stderr b/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
+index c401da52ba87874b51c407c2bb1ccb6269e2f21a..492066310c24681c2d7a94acf552bb810e4af793 100644
+--- a/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
++++ b/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
+@@ -1,20 +1,22 @@
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:33:1
+    |
+ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:38:1
+    |
+ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:84:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+@@ -22,9 +24,10 @@ LL | |     x: &TransparentWrapper<i8x8>,
+ LL | | ) -> TransparentWrapper<i8x8> {
+    | |_____________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:91:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret(
+@@ -32,55 +35,62 @@ LL | |     x: &TransparentWrapper<i8x16>,
+ LL | | ) -> TransparentWrapper<i8x16> {
+    | |______________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:106:1
+    |
+ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:111:1
+    |
+ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:122:1
+    |
+ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:127:1
+    |
+ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:138:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:143:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+ error: aborting due to 10 previous errors
+ 
+diff --git a/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr b/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
+index c401da52ba87874b51c407c2bb1ccb6269e2f21a..492066310c24681c2d7a94acf552bb810e4af793 100644
+--- a/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
++++ b/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
+@@ -1,20 +1,22 @@
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:33:1
+    |
+ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:38:1
+    |
+ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:84:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+@@ -22,9 +24,10 @@ LL | |     x: &TransparentWrapper<i8x8>,
+ LL | | ) -> TransparentWrapper<i8x8> {
+    | |_____________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:91:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret(
+@@ -32,55 +35,62 @@ LL | |     x: &TransparentWrapper<i8x16>,
+ LL | | ) -> TransparentWrapper<i8x16> {
+    | |______________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:106:1
+    |
+ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:111:1
+    |
+ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:122:1
+    |
+ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:127:1
+    |
+ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:138:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:143:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+ error: aborting due to 10 previous errors
+ 
+diff --git a/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr b/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
+index 59697d6af254a67c8380c94dfa4b4f5b0f421d51..d1d8389752d5d92ac1e84093efc3a060e550507b 100644
+--- a/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
++++ b/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
+@@ -8,23 +8,25 @@ warning: target feature `soft-float` must be disabled to ensure that the ABI of
+    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:33:1
+    |
+ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:38:1
+    |
+ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:84:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+@@ -32,9 +34,10 @@ LL | |     x: &TransparentWrapper<i8x8>,
+ LL | | ) -> TransparentWrapper<i8x8> {
+    | |_____________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:91:1
+    |
+ LL | / extern "C" fn vector_transparent_wrapper_ret(
+@@ -42,55 +45,62 @@ LL | |     x: &TransparentWrapper<i8x16>,
+ LL | | ) -> TransparentWrapper<i8x16> {
+    | |______________________________^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:106:1
+    |
+ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 8>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Simd<i8, 16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:111:1
+    |
+ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Simd<i8, 16>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:122:1
+    |
+ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `Wrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:127:1
+    |
+ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `Wrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 8>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:138:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 8>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+-error: this function definition uses SIMD vector type `TransparentWrapper<Simd<i8, 16>>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
++error: this function definition requires the `vector` target feature, which is not enabled
+   --> $DIR/simd-abi-checks-s390x.rs:143:1
+    |
+ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
++   = note: the function has type `TransparentWrapper<Simd<i8, 16>>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+ 
+ error: aborting due to 10 previous errors; 2 warnings emitted
+ 
+diff --git a/tests/ui/abi/simd-abi-checks-sse.rs b/tests/ui/abi/simd-abi-checks-sse.rs
+index 736f32afcd4648790269b0aaf331f23d67a39bac..906b6ec65610ef7ad40786f05a14ec5d29f8e24c 100644
+--- a/tests/ui/abi/simd-abi-checks-sse.rs
++++ b/tests/ui/abi/simd-abi-checks-sse.rs
+@@ -6,6 +6,7 @@
+ //@ build-fail
+ //@ needs-llvm-components: x86
+ //@ ignore-backends: gcc
++//@ dont-require-annotations: NOTE
+ #![feature(no_core)]
+ #![no_core]
+ #![allow(improper_ctypes_definitions)]
+@@ -15,5 +16,6 @@ use minicore::simd::Simd;
+ 
+ #[no_mangle]
+ pub unsafe extern "C" fn f(_: Simd<i64, 2>) {
+-    //~^ ERROR: this function definition uses SIMD vector type `Simd<i64, 2>` which (with the chosen ABI) requires the `sse` target feature, which is not enabled
++    //~^ ERROR: requires the `sse` target feature
++    //~| NOTE: the function has type `Simd<i64, 2>` in its signature, which is passed in SIMD vector registers under the "C" ABI
+ }
+diff --git a/tests/ui/abi/simd-abi-checks-sse.stderr b/tests/ui/abi/simd-abi-checks-sse.stderr
+index 1a6583a511e0c6caa2c0ed1081cf3c51e603374e..91f3f851fa2ca0aa814c6cedc2758c48f06cf31b 100644
+--- a/tests/ui/abi/simd-abi-checks-sse.stderr
++++ b/tests/ui/abi/simd-abi-checks-sse.stderr
+@@ -1,10 +1,11 @@
+-error: this function definition uses SIMD vector type `Simd<i64, 2>` which (with the chosen ABI) requires the `sse` target feature, which is not enabled
+-  --> $DIR/simd-abi-checks-sse.rs:17:1
++error: this function definition requires the `sse` target feature, which is not enabled
++  --> $DIR/simd-abi-checks-sse.rs:18:1
+    |
+ LL | pub unsafe extern "C" fn f(_: Simd<i64, 2>) {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+sse`) or locally (`#[target_feature(enable="sse")]`)
++   = note: the function has type `Simd<i64, 2>` in its signature, which is passed in SIMD vector registers under the "C" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+sse`) or locally (`#[target_feature(enable="sse")]`)
+ 
+ error: aborting due to 1 previous error
+ 
+diff --git a/tests/ui/scalable-vectors/require-target-feature.rs b/tests/ui/scalable-vectors/require-target-feature.rs
+index b3c1d3e510077bdd16bcbae9a59709bc6123399d..42194d2351a90693daee52e27352c87a2ed183e9 100644
+--- a/tests/ui/scalable-vectors/require-target-feature.rs
++++ b/tests/ui/scalable-vectors/require-target-feature.rs
+@@ -1,18 +1,27 @@
+ //@ build-fail
+-//@ compile-flags: --crate-type=lib
+-//@ only-aarch64
++//@ compile-flags: --crate-type=lib --target=aarch64-unknown-linux-gnu
++//@ needs-llvm-components: aarch64
++//@ add-minicore
++//@ dont-require-annotations: NOTE
++
+ #![allow(incomplete_features, internal_features)]
+ #![feature(
+     simd_ffi,
+     rustc_attrs,
+-    link_llvm_intrinsics
++    link_llvm_intrinsics,
++    no_core
+ )]
++#![no_core]
++
++extern crate minicore;
++use minicore::*;
+ 
+-#[derive(Copy, Clone)]
+ #[rustc_scalable_vector(4)]
+ #[allow(non_camel_case_types)]
+ pub struct svint32_t(i32);
+ 
++impl Copy for svint32_t {}
++
+ #[inline(never)]
+ #[target_feature(enable = "sve")]
+ pub unsafe fn svdup_n_s32(op: i32) -> svint32_t {
+@@ -25,7 +34,8 @@ pub unsafe fn svdup_n_s32(op: i32) -> svint32_t {
+ }
+ 
+ pub fn non_annotated_callee(x: svint32_t) {}
+-//~^ ERROR: this function definition uses scalable vector type `svint32_t`
++//~^ ERROR: this function definition requires the `sve` target feature
++//~| NOTE: the function has type `svint32_t` in its signature, which is passed in scalable vector registers under the "Rust" ABI
+ 
+ #[target_feature(enable = "sve")]
+ pub fn annotated_callee(x: svint32_t) {} // okay!
+diff --git a/tests/ui/scalable-vectors/require-target-feature.stderr b/tests/ui/scalable-vectors/require-target-feature.stderr
+index 85b9e5b6579ce31d56bb7104275287839fb55a63..626b6817ce75be2edead876001246c3a3c4dbf32 100644
+--- a/tests/ui/scalable-vectors/require-target-feature.stderr
++++ b/tests/ui/scalable-vectors/require-target-feature.stderr
+@@ -1,5 +1,5 @@
+ warning: `extern` block uses type `svint32_t`, which is not FFI-safe
+-  --> $DIR/require-target-feature.rs:21:37
++  --> $DIR/require-target-feature.rs:30:37
+    |
+ LL |         fn _svdup_n_s32(op: i32) -> svint32_t;
+    |                                     ^^^^^^^^^ not FFI-safe
+@@ -7,19 +7,20 @@ LL |         fn _svdup_n_s32(op: i32) -> svint32_t;
+    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+    = note: this struct has unspecified layout
+ note: the type is defined here
+-  --> $DIR/require-target-feature.rs:14:1
++  --> $DIR/require-target-feature.rs:21:1
+    |
+ LL | pub struct svint32_t(i32);
+    | ^^^^^^^^^^^^^^^^^^^^
+    = note: `#[warn(improper_ctypes)]` on by default
+ 
+-error: this function definition uses scalable vector type `svint32_t` which (with the chosen ABI) requires the `sve` target feature, which is not enabled
+-  --> $DIR/require-target-feature.rs:27:1
++error: this function definition requires the `sve` target feature, which is not enabled
++  --> $DIR/require-target-feature.rs:36:1
+    |
+ LL | pub fn non_annotated_callee(x: svint32_t) {}
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+    |
+-   = help: consider enabling it globally (`-C target-feature=+sve`) or locally (`#[target_feature(enable="sve")]`)
++   = note: the function has type `svint32_t` in its signature, which is passed in scalable vector registers under the "Rust" ABI
++   = help: consider enabling the missing target feature globally (`-C target-feature=+sve`) or locally (`#[target_feature(enable="sve")]`)
+ 
+ error: aborting due to 1 previous error; 1 warning emitted
+ 

progress/20261028T105419Z/rust-lang--rust-part011-patches.json

@@ -0,0 +1 @@
+{"repository": "rust-lang/rust", "patch_characters": 1435703, "before_characters": 15376687, "after_characters": 15464861, "collected_commits": 39, "status": "running", "updated_at": "2026-10-28T17:24:35.227088+00:00"}